Changeset 9155


Ignore:
Timestamp:
Jun 14, 2014, 10:20:26 PM (11 years ago)
Author:
steve
Message:

Changing validation teststo run in parallel

Location:
trunk/anuga_core/validation_tests/analytical_exact
Files:
38 edited

Legend:

Unmodified
Added
Removed

  • trunk/anuga_core/validation_tests/analytical_exact/avalanche_dry/numerical_avalanche_dry.py

    r8722 r9155  
    1515from time import localtime, strftime, gmtime
    1616from numpy import sin, cos, tan, arctan
    17 
     17from anuga import myid, finalize, distribute
    1818
    1919#-------------------------------------------------------------------------------
    … …  
    4141W = 3*dx
    4242
     43def stage(X,Y):
     44    N = len(X)
     45    w = zeros(N)
     46    for i in range(N):
     47        if X[i]<=0.0:
     48            w[i] = bed_slope*X[i]
     49        else:
     50            w[i] = bed_slope*X[i] + h_0
     51    return w
    4352
    44 # structured mesh
    45 points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (-L/2.0, -W/2.0))
     53def elevation(X,Y):
     54    N = len(X)
     55    y=zeros(N)
     56    for i in range(N):
     57        y[i] = bed_slope*X[i]
     58    return y
    4659
    47 #domain = anuga.Domain(points, vertices, boundary)
    48 domain = Domain(points, vertices, boundary)
    4960
    50 domain.set_name(output_file)               
    51 domain.set_datadir(output_dir)
    52 
    53 #------------------------------------------------------------------------------
    54 # Setup Algorithm, either using command line arguments
    55 # or override manually yourself
    56 #------------------------------------------------------------------------------
    57 from anuga.utilities.argparsing import parse_standard_args
    58 alg, cfl = parse_standard_args()
    59 domain.set_flow_algorithm(alg)
    60 domain.set_CFL(cfl)
    61 
    62 #------------------------------------------------------------------------------
    63 # Setup initial conditions
    64 #------------------------------------------------------------------------------
    65 
    66 # No Mannings friction, but we introduce Coulomb friction below.
    67 domain.set_quantity('friction', 0.0)
    6861class Coulomb_friction:
    6962   
    … …  
    9487friction_slope = 0.05
    9588Coulomb_forcing_term = Coulomb_friction(friction_slope, bed_slope)
    96 domain.forcing_terms.append(Coulomb_forcing_term)
    97 
    98 def stage(X,Y):
    99     N = len(X)
    100     w = zeros(N)
    101     for i in range(N):
    102         if X[i]<=0.0:
    103             w[i] = bed_slope*X[i]
    104         else:
    105             w[i] = bed_slope*X[i] + h_0
    106     return w
    107 domain.set_quantity('stage', stage)
    108 
    109 def elevation(X,Y):
    110     N = len(X)
    111     y=zeros(N)
    112     for i in range(N):
    113         y[i] = bed_slope*X[i]
    114     return y
    115 domain.set_quantity('elevation',elevation)
    11689
    11790def f_right(t):
    … …  
    12396    return [w_r,  u_r*h_r,  0.0]
    12497
     98#------------------------------------------------------------------------------
     99# Setup Algorithm, either using command line arguments
     100# or override manually yourself
     101#------------------------------------------------------------------------------
     102args = anuga.get_args()
     103alg = args.alg
     104cfl = args.cfl
     105verbose = args.v
    125106
     107if myid == 0:
     108   
     109    # structured mesh
     110    points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (-L/2.0, -W/2.0))
     111
     112    #domain = anuga.Domain(points, vertices, boundary)
     113    domain = Domain(points, vertices, boundary)
     114
     115    domain.set_name(output_file)               
     116    domain.set_datadir(output_dir)
     117   
     118    domain.set_flow_algorithm(alg)
     119    #domain.set_CFL(cfl)
     120   
     121    #------------------------------------------------------------------------------
     122    # Setup initial conditions
     123    #------------------------------------------------------------------------------
     124
     125    # No Mannings friction, but we introduce Coulomb friction below.
     126    domain.set_quantity('friction', 0.0)
     127    domain.set_quantity('stage', stage)
     128    domain.set_quantity('elevation',elevation)
     129
     130else:
     131
     132    domain = None
     133
     134
     135domain = distribute(domain)
     136
     137
     138#-----------------------------------------------------------------------------
     139# Special implementation of Coulomb friction
     140#----------------------------------------------------------------------------- 
     141domain.forcing_terms.append(Coulomb_forcing_term)
    126142
    127143
    … …  
    139155
    140156
    141 #===============================================================================
    142 ##from anuga.visualiser import RealtimeVisualiser
    143 ##vis = RealtimeVisualiser(domain)
    144 ##vis.render_quantity_height("stage", zScale =h0*500, dynamic=True)
    145 ##vis.colour_height_quantity('stage', (0.0, 0.5, 1.0))
    146 ##vis.start()
    147 #===============================================================================
    148 
    149157
    150158#------------------------------------------------------------------------------
    151159# Produce a documentation of parameters
    152160#------------------------------------------------------------------------------
    153 parameter_file=open('parameters.tex', 'w')
    154 parameter_file.write('\\begin{verbatim}\n')
    155 from pprint import pprint
    156 pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
    157 parameter_file.write('\\end{verbatim}\n')
    158 parameter_file.close()
     161if myid == 0:
     162    parameter_file=open('parameters.tex', 'w')
     163    parameter_file.write('\\begin{verbatim}\n')
     164    from pprint import pprint
     165    pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
     166    parameter_file.write('\\end{verbatim}\n')
     167    parameter_file.close()
    159168
    160169#------------------------------------------------------------------------------
    … …  
    162171#------------------------------------------------------------------------------
    163172for t in domain.evolve(yieldstep = 0.1, finaltime = 3.):
    164     #print domain.timestepping_statistics(track_speeds=True)
    165     print domain.timestepping_statistics()
    166     #vis.update()
     173    if myid == 0 and verbose: print domain.timestepping_statistics()
     174   
     175
     176domain.sww_merge(delete_old=True)
    167177
    168178
    169 #test against know data
    170    
    171 #vis.evolveFinished()
     179finalize()
    172180
     181

  • trunk/anuga_core/validation_tests/analytical_exact/avalanche_dry/produce_results.py

    r9117 r9155  
    22# import modules
    33#--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities.run_validation import run_validation_script
    6 from anuga.validation_utilities.typeset_report import typeset_report
     4import anuga
     5from anuga.validation_utilities import produce_report
     6
     7args = anuga.get_args()
     8
     9produce_report('numerical_avalanche_dry.py', args=args)
    710
    811
    9 # Setup the python scripts which produce the output for this
    10 # validation test
    11 def build():
    12     run_validation_script('numerical_avalanche_dry.py')
    13     run_validation_script('plot_results.py')
    14     typeset_report()   
    1512
    16 
    17 def clean():
    18     autoclean()
    19 
    20 main()
    21 

  • trunk/anuga_core/validation_tests/analytical_exact/avalanche_dry/validate_avalanche_dry.py

    r9001 r9155  
    1010indent = anuga.indent
    1111
    12 verbose = True
     12args = anuga.get_args()
     13verbose = args.v
    1314
    1415class Test_results(unittest.TestCase):
    … …  
    3233            print indent+'Running simulation script'
    3334
     35           
    3436        s = 'numerical_avalanche_dry.py'
    35         res = os.system('python %s > validate_output.stdout' %s)
     37        res = anuga.run_anuga_script(s,args=args)
     38
    3639
    3740        # Test that script runs ok

  • trunk/anuga_core/validation_tests/analytical_exact/avalanche_wet/numerical_avalanche_wet.py

    r8723 r9155  
    5858alg, cfl = parse_standard_args()
    5959domain.set_flow_algorithm(alg)
    60 domain.set_CFL(cfl)
     60#domain.set_CFL(cfl)
    6161
    6262#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/avalanche_wet/produce_results.py

    r9117 r9155  
    1 #--------------------------------
    2 # import modules
    3 #--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities import run_validation_script
    6 from anuga.validation_utilities import typeset_report
    71
    8 # Setup the python scripts which produce the output for this
    9 # validation test
    10 def build():
    11     run_validation_script('numerical_avalanche_wet.py')
    12     run_validation_script('plot_results.py')
    13     typeset_report()
     2import anuga
     3from anuga.validation_utilities import produce_report
    144
    15 def clean():
    16     autoclean()
     5args = anuga.get_args()
    176
    18 main()
     7produce_report('numerical_avalanche_wet.py', args=args)
    198
     9

  • trunk/anuga_core/validation_tests/analytical_exact/carrier_greenspan_periodic/produce_results.py

    r9117 r9155  
    22# import modules
    33#--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities import run_validation_script
    6 from anuga.validation_utilities import typeset_report
     4import anuga
     5from anuga.validation_utilities import produce_report
    76
    8 # Setup the python scripts which produce the output for this
    9 # validation test
    10 def build():
    11     run_validation_script('numerical_carrier_greenspan.py')
    12     run_validation_script('plot_results_cross_section.py')
    13     run_validation_script('plot_results_origin_wrt_time.py')
    14     typeset_report()   
     7args = anuga.get_args()
     8
     9produce_report('numerical_carrier_greenspan.py', args=args)
    1510
    1611
    17 def clean():
    18     autoclean()
    1912
    20 main()
    21 

  • trunk/anuga_core/validation_tests/analytical_exact/carrier_greenspan_transient/numerical_cg_transient.py

    r8915 r9155  
    1515from scipy.optimize import fsolve
    1616from math import sin, pi, exp, sqrt, cos
    17 from analytical_cg_transient import *
     17from analytical_cg_transient import analytical_sol
     18
     19from anuga import myid, finalize, distribute
     20
     21import warnings
     22warnings.simplefilter('ignore')
     23
     24#------------------------------------------------------------------------------
     25# Setup Algorithm, either using command line arguments
     26# or override manually yourself
     27#------------------------------------------------------------------------------
     28args = anuga.get_args()
     29alg = args.alg
     30cfl = args.cfl
     31verbose = args.v
    1832
    1933
    … …  
    4458
    4559
    46 # structured mesh
    47 points, vertices, boundary = anuga.rectangular_cross(int(0.8*L/dx), int(W/dy), 0.8*L, W, (-0.5*L, -0.5*W))
    48 domain = Domain(points, vertices, boundary)
    49 domain.set_name(output_file)               
    50 domain.set_datadir(output_dir)
    51 
    52 #------------------------------------------------------------------------------
    53 # Setup Algorithm, either using command line arguments
    54 # or override manually yourself
    55 #------------------------------------------------------------------------------
    56 from anuga.utilities.argparsing import parse_standard_args
    57 alg, cfl = parse_standard_args()
    58 domain.set_flow_algorithm(alg)
    59 domain.set_CFL(cfl)
    60 
    61 #------------------------------------------------------------------------------
    62 # Setup initial conditions
    63 #------------------------------------------------------------------------------
    64 domain.set_quantity('friction', 0.0)
    65 
    6660def elevation(x,y):
    6761    return h0*x/L
    68 domain.set_quantity('elevation', elevation)
     62
    6963
    7064def stage(x,y):
    7165    w,z,u = analytical_sol(x/L,0.0)
    7266    return h0*w
    73 domain.set_quantity('stage', stage)
    7467
    7568
     69
     70if myid == 0:
     71    # structured mesh
     72    points, vertices, boundary = anuga.rectangular_cross(int(0.8*L/dx), int(W/dy), 0.8*L, W, (-0.5*L, -0.5*W))
     73    domain = Domain(points, vertices, boundary)
     74    domain.set_name(output_file)               
     75    domain.set_datadir(output_dir)
     76
     77    domain.set_flow_algorithm(alg)
     78    #domain.set_CFL(cfl)
     79
     80    #------------------------------------------------------------------------------
     81    # Setup initial conditions
     82    #------------------------------------------------------------------------------
     83    domain.set_quantity('friction', 0.0)
     84    domain.set_quantity('stage', stage)
     85    domain.set_quantity('elevation', elevation)
     86   
     87else:
     88    domain = None
     89   
     90domain = distribute(domain)
    7691
    7792#-----------------------------------------------------------------------------
    … …  
    106121
    107122
    108 #------------------------------------------------------------------------------
    109 # Produce a documentation of parameters
    110 #------------------------------------------------------------------------------
    111 parameter_file=open('parameters.tex', 'w')
    112 parameter_file.write('\\begin{verbatim}\n')
    113 from pprint import pprint
    114 pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
    115 parameter_file.write('\\end{verbatim}\n')
    116 parameter_file.close()
     123if myid == 0:
     124    #------------------------------------------------------------------------------
     125    # Produce a documentation of parameters
     126    #------------------------------------------------------------------------------
     127    parameter_file=open('parameters.tex', 'w')
     128    parameter_file.write('\\begin{verbatim}\n')
     129    from pprint import pprint
     130    pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
     131    parameter_file.write('\\end{verbatim}\n')
     132    parameter_file.close()
    117133
    118134#------------------------------------------------------------------------------
    … …  
    121137for t in domain.evolve(yieldstep = 1000., finaltime = 30000.):
    122138    #print domain.timestepping_statistics(track_speeds=True)
    123     print domain.timestepping_statistics()
     139    if myid == 0 and verbose:
     140        print domain.timestepping_statistics()
    124141    #vis.update()
    125142
    126143
    127 #test against know data
    128    
    129 #vis.evolveFinished()
     144domain.sww_merge(delete_old=True)
    130145
     146finalize()
     147
     148

  • trunk/anuga_core/validation_tests/analytical_exact/carrier_greenspan_transient/produce_results.py

    r9117 r9155  
    22# import modules
    33#--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities import run_validation_script
    6 from anuga.validation_utilities import typeset_report
     4import anuga
     5from anuga.validation_utilities import produce_report
    76
     7args = anuga.get_args()
    88
    9 # Setup the python scripts which produce the output for this
    10 # validation test
    11 def build():
    12     run_validation_script('numerical_cg_transient.py')
    13     run_validation_script('plot_results.py') 
    14     typeset_report()   
     9produce_report('numerical_cg_transient.py', args=args)
    1510
    16 def clean():
    17     autoclean()
    18 
    19 main()
    20 

  • trunk/anuga_core/validation_tests/analytical_exact/carrier_greenspan_transient/validate_carrier_greenspan_transient.py

    r9138 r9155  
    122122
    123123        for i, id in enumerate(ids):
    124             assert euh[i] < 0.02,  'L^1 error %g greater than 2 percent'% euh[i]
     124            assert euh[i] < 0.025,  'L^1 error %g greater than 2 percent'% euh[i]
    125125           
    126126

  • trunk/anuga_core/validation_tests/analytical_exact/dam_break_dry/numerical_dam_break_dry.py

    r9137 r9155  
    4848    return z
    4949
     50
     51args = anuga.get_args()
     52alg = args.alg
     53cfl = args.cfl
     54verbose = args.v
     55
     56print args
     57
     58
    5059#================================================================================
    5160# create sequential domain
    … …  
    6574    # or override manually yourself
    6675    #------------------------------------------------------------------------------
    67     from anuga.utilities.argparsing import parse_standard_args
    68     alg, cfl = parse_standard_args()
    6976    domain.set_flow_algorithm(alg)
    70     domain.set_CFL(cfl)
     77    #domain.set_CFL(cfl)
    7178
    7279    #------------------------------------------------------------------------------
    … …  
    121128#===================================================================================
    122129for t in domain.evolve(yieldstep = 0.5, finaltime = 50.):
    123     if myid == 0:
     130    if myid == 0 and verbose:
    124131        print domain.timestepping_statistics()
    125132

  • trunk/anuga_core/validation_tests/analytical_exact/dam_break_dry/produce_results.py

    r9117 r9155  
    22# import modules
    33#--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities import run_validation_script
    6 from anuga.validation_utilities import typeset_report
    74
    8 # Setup the python scripts which produce the output for this
    9 # validation test
    10 def build():
    11     run_validation_script('numerical_dam_break_dry.py')
    12     run_validation_script('plot_results.py')
    13     typeset_report()
     5import anuga
     6from anuga.validation_utilities import produce_report
    147
    15    
    16 def clean():
    17     autoclean()
     8args = anuga.get_args()
    189
    19 main()
     10produce_report('numerical_dam_break_dry.py', args=args)
    2011
     12
     13
     14
     15
     16

  • trunk/anuga_core/validation_tests/analytical_exact/dam_break_dry/validate_dam_break_dry.py

    r8995 r9155  
    88import anuga
    99
     10args = anuga.get_args()
     11
     12
    1013indent = anuga.indent
    1114
    12 verbose = True
     15verbose = args.v
    1316
    1417class Test_results(unittest.TestCase):
    … …  
    3235            print indent+'Running simulation script'
    3336
    34         s = 'produce_results.py'
    35         res = os.system('python %s > validate_output.stdout' %s)
     37        s = 'numerical_dam_break_dry.py'
     38        res = anuga.run_anuga_script(s,args=args)
    3639
    3740        # Test that script runs ok

  • trunk/anuga_core/validation_tests/analytical_exact/dam_break_wet/numerical_dam_break_wet.py

    r9137 r9155  
    6464    alg, cfl = parse_standard_args()
    6565    domain.set_flow_algorithm(alg)
    66     domain.set_CFL(cfl)
     66    #domain.set_CFL(cfl)
    6767
    6868    #------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/dam_break_wet/produce_results.py

    r9117 r9155  
    22# import modules
    33#--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities import run_validation_script
    6 from anuga.validation_utilities import typeset_report
     4
     5import anuga
     6from anuga.validation_utilities import produce_report
     7
     8args = anuga.get_args()
     9
     10produce_report('numerical_dam_break_wet.py', args=args)
    711
    812
    9 # Setup the python scripts which produce the output for this
    10 # validation test
    11 def build():
    12     run_validation_script('numerical_dam_break_wet.py')
    13     run_validation_script('plot_results.py')
    14     typeset_report()
    15 
    16 def clean():
    17     autoclean()
    18 
    19 main()
    20 

  • trunk/anuga_core/validation_tests/analytical_exact/dam_break_wet/validate_dam_break_wet.py

    r8786 r9155  
    88import anuga
    99
     10args = anuga.get_args()
     11
    1012indent = anuga.indent
    1113
    12 verbose = True
     14verbose = args.v
    1315
    1416class Test_results(unittest.TestCase):
    … …  
    3234            print indent+'Running simulation script'
    3335
    34         s = 'produce_results.py'
    35         res = os.system('python %s > validate_output.stdout' %s)
     36        s = 'numerical_dam_break_wet.py'
     37        res = anuga.run_anuga_script(s,args=args)
    3638
    3739        # Test that script runs ok

  • trunk/anuga_core/validation_tests/analytical_exact/deep_wave/produce_results.py

    r9117 r9155  
    1 from anuga.validation_utilities.fabricate import *
    21#--------------------------------
    32# import modules
    43#--------------------------------
    5 from anuga.validation_utilities.fabricate import *
    6 from anuga.validation_utilities import run_validation_script
    7 from anuga.validation_utilities import typeset_report
     4import anuga
     5from anuga.validation_utilities import produce_report
    86
    9 # Setup the python scripts which produce the output for this
    10 # validation test
    11 def build():
    12     run_validation_script('run_wave.py')
    13     run_validation_script('plot_results.py')
    14     typeset_report()
     7args = anuga.get_args()
    158
    16 def clean():
    17     autoclean()
     9produce_report('run_wave.py', args=args)
    1810
    19 main()

  • trunk/anuga_core/validation_tests/analytical_exact/deep_wave/run_wave.py

    r9035 r9155  
    1111import anuga
    1212from anuga import Domain
     13from anuga import myid, finalize, distribute
    1314
    14 #from balanced_dev import *
    15 #from balanced_dev import Domain as Domain
     15
    1616
    1717from math import cos
    … …  
    2525# algorithm parameters.
    2626#--------------------------------
    27 from anuga.utilities.argparsing import parse_standard_args
    28 alg, cfl = parse_standard_args()
     27args = anuga.get_args()
     28alg = args.alg
    2929
    3030#-------------------------------------------------------------------------------
    … …  
    4242interactive_visualisation = False
    4343
    44 #------------------------------------------------------------------------------
    45 # Setup domain
    46 #------------------------------------------------------------------------------
    47 dx = 500.
    48 dy = dx
    49 L = 100000.
    50 W = 10*dx
     44if myid == 0:
     45    #------------------------------------------------------------------------------
     46    # Setup sequential domain
     47    #------------------------------------------------------------------------------
     48    dx = 500.
     49    dy = dx
     50    L = 100000.
     51    W = 10*dx
     52   
     53    # structured mesh
     54    points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (0.0, -W/2))
     55   
     56    domain = Domain(points, vertices, boundary)
     57   
     58    domain.set_name(output_file)               
     59    domain.set_datadir(output_dir) 
     60   
     61    #------------------------------------------------------------------------------
     62    # Setup Algorithm, either using command line arguments
     63    # or override manually yourself
     64    #------------------------------------------------------------------------------
     65    from anuga.utilities.argparsing import parse_standard_args
     66    alg, cfl = parse_standard_args()
     67    domain.set_flow_algorithm(alg)
     68    #domain.set_CFL(cfl)
     69   
     70   
     71    #------------------------------------------------------------------------------
     72    # Setup initial conditions
     73    #------------------------------------------------------------------------------
     74    domain.set_quantity('elevation',-100.0)
     75    domain.set_quantity('friction', 0.00)
     76    domain.set_quantity('stage', 0.0)           
    5177
    52 # structured mesh
    53 points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (0.0, -W/2))
     78else:
    5479
    55 domain = Domain(points, vertices, boundary)
    56 
    57 domain.set_name(output_file)               
    58 domain.set_datadir(output_dir) 
    59 
    60 #------------------------------------------------------------------------------
    61 # Setup Algorithm, either using command line arguments
    62 # or override manually yourself
    63 #------------------------------------------------------------------------------
    64 from anuga.utilities.argparsing import parse_standard_args
    65 alg, cfl = parse_standard_args()
    66 domain.set_flow_algorithm(alg)
    67 domain.set_CFL(cfl)
    68 
    69 
    70 #------------------------------------------------------------------------------
    71 # Setup initial conditions
    72 #------------------------------------------------------------------------------
    73 domain.set_quantity('elevation',-100.0)
    74 domain.set_quantity('friction', 0.00)
    75 domain.set_quantity('stage', 0.0)           
    76 
     80    domain = None
     81   
     82#-----------------------------------------------------------------------------------
     83# Parallel Domain
     84#-----------------------------------------------------------------------------------
     85domain = distribute(domain)
     86   
    7787#-----------------------------------------------------------------------------
    7888# Setup boundary conditions
    … …  
    101111    return amplitude*sin((1./wave_length)*t*2*pi)
    102112
    103 Bw2 = anuga.shallow_water.boundaries.Transmissive_n_momentum_zero_t_momentum_set_stage_boundary(domain, waveform2)
     113Bw2 = anuga.Transmissive_n_momentum_zero_t_momentum_set_stage_boundary(domain, waveform2)
    104114#Bw3 = swb2_boundary_conditions.Transmissive_momentum_nudge_stage_boundary(domain, waveform)
    105115Bw3 = anuga.Time_boundary(domain, waveform)
    … …  
    115125
    116126
    117 #===============================================================================
    118 if interactive_visualisation:
    119     from anuga.visualiser import RealtimeVisualiser
    120     vis = RealtimeVisualiser(domain)
    121     vis.render_quantity_height("stage", zScale =10000, dynamic=True)
    122     vis.colour_height_quantity('stage', (1.0, 0.5, 0.5))
    123     vis.start()
    124 #===============================================================================
    125127
    126128
    … …  
    128130# Produce a documentation of parameters
    129131#------------------------------------------------------------------------------
    130 parameter_file=open('parameters.tex', 'w')
    131 parameter_file.write('\\begin{verbatim}\n')
    132 from pprint import pprint
    133 pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
    134 parameter_file.write('\\end{verbatim}\n')
    135 parameter_file.close()
     132if myid == 0:
     133    parameter_file=open('parameters.tex', 'w')
     134    parameter_file.write('\\begin{verbatim}\n')
     135    from pprint import pprint
     136    pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
     137    parameter_file.write('\\end{verbatim}\n')
     138    parameter_file.close()
    136139
    137140#------------------------------------------------------------------------------
    … …  
    144147        vis.update()
    145148
    146 if interactive_visualisation:
    147     vis.evolveFinished()
     149domain.sww_merge(delete_old=True)
    148150
     151finalize()
     152

  • trunk/anuga_core/validation_tests/analytical_exact/lake_at_rest_immersed_bump/numerical_immersed_bump.py

    r8777 r9155  
    1515from time import localtime, strftime, gmtime
    1616#from balanced_dev import *
    17 
     17from anuga import myid, finalize, distribute
    1818
    1919#-------------------------------------------------------------------------------
    … …  
    2727output_file = 'immersed_bump'
    2828
    29 #anuga.copy_code_files(output_dir,__file__)
    30 #start_screen_catcher(output_dir+'_')
    31 
    32 
    33 #------------------------------------------------------------------------------
    34 # Setup domain
    35 #------------------------------------------------------------------------------
    36 dx = 1.
    37 dy = dx
    38 L = 25.
    39 W = 5*dx
    40 
    41 # structured mesh
    42 points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (0.0, 0.0))
    43 
    44 #domain = anuga.Domain(points, vertices, boundary)
    45 domain = Domain(points, vertices, boundary)
    46 
    47 domain.set_name(output_file)               
    48 domain.set_datadir(output_dir)
    49 
    50 #------------------------------------------------------------------------------
    51 # Setup Algorithm, either using command line arguments
    52 # or override manually yourself
    53 #------------------------------------------------------------------------------
    54 from anuga.utilities.argparsing import parse_standard_args
    55 alg, cfl = parse_standard_args()
    56 domain.set_flow_algorithm(alg)
    57 domain.set_CFL(cfl)
    58 
    59 #------------------------------------------------------------------------------
    60 # Setup initial conditions
    61 #------------------------------------------------------------------------------
    62 domain.set_quantity('friction', 0.0)
    63 domain.set_quantity('stage', 0.5)
    64 
    6529def bed_elevation(x,y):
    6630    z = zeros(len(x), float)
    … …  
    7135            z[i] = 0.0
    7236    return z   
    73 domain.set_quantity('elevation', bed_elevation)
     37
     38
     39args = anuga.get_args()
     40alg = args.alg
     41verbose = args.v
     42
     43if myid == 0:
     44    #------------------------------------------------------------------------------
     45    # Setup domain
     46    #------------------------------------------------------------------------------
     47    dx = 1.
     48    dy = dx
     49    L = 25.
     50    W = 5*dx
     51   
     52    # structured mesh
     53    points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (0.0, 0.0))
     54   
     55    #domain = anuga.Domain(points, vertices, boundary)
     56    domain = Domain(points, vertices, boundary)
     57   
     58    domain.set_name(output_file)               
     59    domain.set_datadir(output_dir)
     60
     61    domain.set_flow_algorithm(alg)
     62
     63   
     64    #------------------------------------------------------------------------------
     65    # Setup initial conditions
     66    #------------------------------------------------------------------------------
     67    domain.set_quantity('friction', 0.0)
     68    domain.set_quantity('stage', 0.5)   
     69    domain.set_quantity('elevation', bed_elevation)
     70
     71else:
     72   
     73    domain = None
     74   
     75#-----------------------------------------------------------------------------
     76# Parallel Domain
     77#-----------------------------------------------------------------------------   
     78domain = distribute(domain)
    7479
    7580#-----------------------------------------------------------------------------
    … …  
    8590
    8691
    87 #===============================================================================
    88 ##from anuga.visualiser import RealtimeVisualiser
    89 ##vis = RealtimeVisualiser(domain)
    90 ##vis.render_quantity_height("stage", zScale =h0*500, dynamic=True)
    91 ##vis.colour_height_quantity('stage', (0.0, 0.5, 1.0))
    92 ##vis.start()
    93 #===============================================================================
    9492
    9593
    … …  
    9795# Produce a documentation of parameters
    9896#------------------------------------------------------------------------------
    99 parameter_file=open('parameters.tex', 'w')
    100 parameter_file.write('\\begin{verbatim}\n')
    101 from pprint import pprint
    102 pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
    103 parameter_file.write('\\end{verbatim}\n')
    104 parameter_file.close()
     97if myid == 0:
     98    parameter_file=open('parameters.tex', 'w')
     99    parameter_file.write('\\begin{verbatim}\n')
     100    from pprint import pprint
     101    pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
     102    parameter_file.write('\\end{verbatim}\n')
     103    parameter_file.close()
    105104
    106105#------------------------------------------------------------------------------
    … …  
    109108for t in domain.evolve(yieldstep = 0.1, finaltime = 5.):
    110109    #print domain.timestepping_statistics(track_speeds=True)
    111     print domain.timestepping_statistics()
    112     #vis.update()
     110    if myid == 0: print domain.timestepping_statistics()
    113111
     112domain.sww_merge(delete_old=True)
    114113
    115 #test against know data
    116    
    117 #vis.evolveFinished()
     114finalize()
    118115

  • trunk/anuga_core/validation_tests/analytical_exact/lake_at_rest_immersed_bump/produce_results.py

    r9117 r9155  
    22# import modules
    33#--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities import run_validation_script
    6 from anuga.validation_utilities import typeset_report
     4import anuga
     5from anuga.validation_utilities import produce_report
    76
     7args = anuga.get_args()
    88
    9 # Setup the python scripts which produce the output for this
    10 # validation test
    11 def build():
    12     run_validation_script('numerical_immersed_bump.py')
    13     run_validation_script('plot_results.py')
    14     typeset_report()
    15 
    16 def clean():
    17     autoclean()
    18 
    19 main()
    20 
     9produce_report('numerical_immersed_bump.py', args=args)

  • trunk/anuga_core/validation_tests/analytical_exact/lake_at_rest_steep_island/numerical_steep_island.py

    r8778 r9155  
    1414from numpy import zeros, float
    1515from time import localtime, strftime, gmtime
    16 #from balanced_dev import *
     16from anuga import myid, finalize, distribute
    1717
    1818
    … …  
    2727output_file = 'steep_island'
    2828
    29 #anuga.copy_code_files(output_dir,__file__)
    30 #start_screen_catcher(output_dir+'_')
     29args = anuga.get_args()
     30alg = args.alg
     31verbose = args.v
    3132
    32 
    33 #------------------------------------------------------------------------------
    34 # Setup domain
    35 #------------------------------------------------------------------------------
    3633dx = 1.
    3734dy = dx
    3835L = 2000.
    3936W = 5*dx
    40 
    41 # structured mesh
    42 points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (0.0, 0.0))
    43 
    44 #domain = anuga.Domain(points, vertices, boundary)
    45 domain = Domain(points, vertices, boundary)
    46 
    47 domain.set_name(output_file)               
    48 domain.set_datadir(output_dir)
    49 
    50 #------------------------------------------------------------------------------
    51 # Setup Algorithm, either using command line arguments
    52 # or override manually yourself
    53 #------------------------------------------------------------------------------
    54 from anuga.utilities.argparsing import parse_standard_args
    55 alg, cfl = parse_standard_args()
    56 domain.set_flow_algorithm(alg)
    57 domain.set_CFL(cfl)
    58 
    59 #------------------------------------------------------------------------------
    60 # Setup initial conditions
    61 #------------------------------------------------------------------------------
    62 domain.set_quantity('friction', 0.0)
    6337
    6438def stage_flat(x,y):
    … …  
    6741        w[i]=4.5
    6842    return w
    69 domain.set_quantity('stage', stage_flat)
    7043
    7144def bed_elevation(x,y):
    … …  
    9972            z[i] = (4.5/40000)*(x[i]-1800)*(x[i]-1800) + 2.0
    10073    return z
    101 domain.set_quantity('elevation', bed_elevation)
     74
     75#------------------------------------------------------------------------------
     76# Setup sequential domain
     77#------------------------------------------------------------------------------
     78if myid == 0:
     79    # structured mesh
     80    points, vertices, boundary = anuga.rectangular_cross(int(L/dx), int(W/dy), L, W, (0.0, 0.0))
     81 
     82    domain = Domain(points, vertices, boundary)
     83   
     84    domain.set_name(output_file)               
     85    domain.set_datadir(output_dir)
     86    domain.set_flow_algorithm(alg)
     87   
     88    #------------------------------------------------------------------------------
     89    # Setup initial conditions
     90    #------------------------------------------------------------------------------
     91    domain.set_quantity('friction', 0.0)
     92    domain.set_quantity('stage', stage_flat)
     93    domain.set_quantity('elevation', bed_elevation)
     94   
     95else:
     96   
     97    domain = None
     98   
     99#-----------------------------------------------------------------------------
     100# Parallel Domain
     101#-----------------------------------------------------------------------------
     102domain = distribute(domain)   
    102103
    103104#-----------------------------------------------------------------------------
    … …  
    113114
    114115
    115 #===============================================================================
    116 ##from anuga.visualiser import RealtimeVisualiser
    117 ##vis = RealtimeVisualiser(domain)
    118 ##vis.render_quantity_height("stage", zScale =h0*500, dynamic=True)
    119 ##vis.colour_height_quantity('stage', (0.0, 0.5, 1.0))
    120 ##vis.start()
    121 #===============================================================================
    122116
    123117
    … …  
    125119# Produce a documentation of parameters
    126120#------------------------------------------------------------------------------
    127 parameter_file=open('parameters.tex', 'w')
    128 parameter_file.write('\\begin{verbatim}\n')
    129 from pprint import pprint
    130 pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
    131 parameter_file.write('\\end{verbatim}\n')
    132 parameter_file.close()
     121if myid == 0:
     122    parameter_file=open('parameters.tex', 'w')
     123    parameter_file.write('\\begin{verbatim}\n')
     124    from pprint import pprint
     125    pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
     126    parameter_file.write('\\end{verbatim}\n')
     127    parameter_file.close()
    133128
    134129#------------------------------------------------------------------------------
    … …  
    137132for t in domain.evolve(yieldstep = 0.1, finaltime = 5.):
    138133    #print domain.timestepping_statistics(track_speeds=True)
    139     print domain.timestepping_statistics()
    140     #vis.update()
     134    if myid == 0: print domain.timestepping_statistics()
    141135
    142136
    143 #test against know data
    144    
    145 #vis.evolveFinished()
     137domain.sww_merge(delete_old=True)
    146138
     139finalize()
     140
     141
     142#
     143

  • trunk/anuga_core/validation_tests/analytical_exact/lake_at_rest_steep_island/produce_results.py

    r9117 r9155  
    22# import modules
    33#--------------------------------
    4 from anuga.validation_utilities.fabricate import *
    5 from anuga.validation_utilities import run_validation_script
    6 from anuga.validation_utilities import typeset_report
     4import anuga
     5from anuga.validation_utilities import produce_report
     6
     7args = anuga.get_args()
     8
     9produce_report('numerical_steep_island.py', args=args)
    710
    811
    9 # Setup the python scripts which produce the output for this
    10 # validation test
    11 def build():
    12     run_validation_script('numerical_steep_island.py')
    13     run_validation_script('plot_results.py')
    14     typeset_report()
    15 
    16 def clean():
    17     autoclean()
    18 
    19 main()
    20 

  • trunk/anuga_core/validation_tests/analytical_exact/landslide_tsunami/runup.py

    r9038 r9155  
    3737alg, cfl = parse_standard_args()
    3838domain.set_flow_algorithm(alg)
    39 domain.set_CFL(cfl)
     39#domain.set_CFL(cfl)
    4040
    4141#------------------

  • trunk/anuga_core/validation_tests/analytical_exact/mac_donald_short_channel/numerical_MacDonald.py

    r8783 r9155  
    5454alg, cfl = parse_standard_args()
    5555domain.set_flow_algorithm(alg)
    56 domain.set_CFL(cfl)
     56#domain.set_CFL(cfl)
    5757
    5858#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/parabolic_basin/numerical_parabolic_basin.py

    r8788 r9155  
    4545alg, cfl = parse_standard_args()
    4646domain.set_flow_algorithm(alg)
    47 domain.set_CFL(cfl)
     47#domain.set_CFL(cfl)
    4848
    4949#------------------

  • trunk/anuga_core/validation_tests/analytical_exact/paraboloid_basin/numerical_paraboloid_basin.py

    r8868 r9155  
    6363#domain.set_timestepping_method(2)
    6464#domain.set_beta(1.5)
    65 #domain.set_CFL(0.6)
     65##domain.set_CFL(0.6)
    6666#domain.smooth = True
    6767

  • trunk/anuga_core/validation_tests/analytical_exact/river_at_rest_varying_topo_width/numerical_varying_width.py

    r8886 r9155  
    5858alg, cfl = parse_standard_args()
    5959domain.set_flow_algorithm(alg)
    60 domain.set_CFL(cfl)
     60#domain.set_CFL(cfl)
    6161
    6262#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/river_at_rest_varying_topo_width/results.tex

    r8886 r9155  
     1
     2
    13
    24\section{River at rest with varying width and topography}

  • trunk/anuga_core/validation_tests/analytical_exact/rundown_mild_slope/numerical_rundown_channel.py

    r8793 r9155  
    2727alg, cfl = parse_standard_args()
    2828domain.set_flow_algorithm(alg)
    29 domain.set_CFL(cfl)
     29#domain.set_CFL(cfl)
    3030
    3131#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/rundown_mild_slope/plot_results.py

    r8792 r9155  
    4747pyplot.clf()
    4848
    49 line, = pyplot.plot( (p2.x[v].min(),p2.x[v].max()) ,( (p2.stage[:,v]-p2.elev[:,v]).max(),(p2.stage[:,v]-p2.elev[v]).min() ) )
     49line, = pyplot.plot( (p2.x[v].min(),p2.x[v].max()) ,( (p2.stage[:,v]-p2.elev[v]).max(),(p2.stage[:,v]-p2.elev[v]).min() ) )
    5050line.set_label('numerical')
    5151pyplot.plot( (0,100),(dana,dana), 'r',label='analytical' )

  • trunk/anuga_core/validation_tests/analytical_exact/rundown_mild_slope_coarse/numerical_rundown_channel_coarse.py

    r9056 r9155  
    2727alg, cfl = parse_standard_args()
    2828domain.set_flow_algorithm(alg)
    29 domain.set_CFL(cfl)
     29#domain.set_CFL(cfl)
    3030
    3131#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/rundown_mild_slope_coarse/plot_results.py

    r9150 r9155  
    5353pyplot.clf()
    5454
    55 
    56 print (p2.x[v].min(),p2.x[v].max())
    57 print (p2.stage[:,v]-p2.elev[v]).max()
    58 print (p2.stage[:,v]-p2.elev[v]).min()
    59 
    6055line, = pyplot.plot( (p2.x[v].min(),p2.x[v].max()) ,( (p2.stage[:,v]-p2.elev[v]).max(),(p2.stage[:,v]-p2.elev[v]).min() ) )
    6156line.set_label('numerical')

  • trunk/anuga_core/validation_tests/analytical_exact/runup_on_beach/numerical_runup.py

    r8796 r9155  
    2626alg, cfl = parse_standard_args()
    2727domain.set_flow_algorithm(alg)
    28 domain.set_CFL(cfl)
     28#domain.set_CFL(cfl)
    2929#domain.set_minimum_allowed_height(0.0001)
    3030#domain.set_minimum_storable_height(0.0001)

  • trunk/anuga_core/validation_tests/analytical_exact/runup_on_sinusoid_beach/numerical_runup_sinusoid.py

    r9036 r9155  
    2323alg, cfl = parse_standard_args()
    2424domain.set_flow_algorithm(alg)
    25 domain.set_CFL(cfl)
     25#domain.set_CFL(cfl)
    2626domain.set_name('runup_sinusoid')                         # Output to file runup.sww
    2727domain.set_datadir('.')                          # Use current folder

  • trunk/anuga_core/validation_tests/analytical_exact/subcritical_over_bump/numerical_subcritical.py

    r8797 r9155  
    5454alg, cfl = parse_standard_args()
    5555domain.set_flow_algorithm(alg)
    56 domain.set_CFL(cfl)
     56#domain.set_CFL(cfl)
    5757
    5858#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/transcritical_with_shock/numerical_transcritical.py

    r8799 r9155  
    5454alg, cfl = parse_standard_args()
    5555domain.set_flow_algorithm(alg)
    56 domain.set_CFL(cfl)
     56#domain.set_CFL(cfl)
    5757
    5858#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/transcritical_without_shock/numerical_transcritical.py

    r8800 r9155  
    5757alg, cfl = parse_standard_args()
    5858domain.set_flow_algorithm(alg)
    59 domain.set_CFL(cfl)
     59#domain.set_CFL(cfl)
    6060
    6161#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/trapezoidal_channel/numerical_channel_floodplain.py

    r9038 r9155  
    8383alg, cfl = parse_standard_args()
    8484domain.set_flow_algorithm(alg)
    85 domain.set_CFL(cfl)
     85#domain.set_CFL(cfl)
    8686
    8787#------------------------------------------------------------------------------

  • trunk/anuga_core/validation_tests/analytical_exact/trapezoidal_channel/results.tex

    r8912 r9155  
    3333
    3434
    35 \DTLloaddb{dischargeout}{analytical_exact/trapezoidal_channel/discharge_outputs.txt}
     35\DTLloaddb{dischargeout}{../analytical_exact/trapezoidal_channel/discharge_outputs.txt}
    3636%\DTLloaddb{dischargeout}{discharge_outputs.txt}
    3737\begin{table}
Note: See TracChangeset for help on using the changeset viewer.