Changeset 8464


Ignore:
Timestamp:
Jul 10, 2012, 8:37:14 PM (13 years ago)
Author:
steve
Message:

Working on validation tests

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/anuga_core/validation_tests/Tests/Experimental/Isolated_Building/produce_results.py

    r8460 r8464  
    1 #--------------------------------
    2 # Setup Default values for basis
    3 # algorithm parameters.
    4 #--------------------------------
    5 import argparse
    6 parser = argparse.ArgumentParser(description='produce results')
    7 parser.add_argument('-cfl', type=float, default=1.0,
    8                    help='cfl condition')
    9 parser.add_argument('-alg', type=str, default = "1_5",
    10                    help='flow algorithm')
    11 args = parser.parse_args()
     1from anuga.utilities.validations import run_validation_script
    122
    13 cfl = args.cfl
    14 alg = args.alg
     3
     4#run_validation_script('run_problem.py')
     5#run_validation_script('plot_problem.py')
    156
    167
    178
    18 import dam_break
    19 import plot_results
    20 
    21 

  • trunk/anuga_core/validation_tests/Tests/Experimental/Okushiri/compare_timeseries_with_measures.py

    r8461 r8464  
    126126#--------------------------------------------------
    127127
    128 if len(sys.argv) > 1:
    129     sww_filename = sys.argv[1]
    130 else:   
    131     sww_filename = project.output_filename
     128#if len(sys.argv) > 1:
     129#    sww_filename = sys.argv[1]
     130#else:
     131sww_filename = project.output_filename
    132132   
    133133f = file_function(sww_filename,
    134134                  quantities='stage',
    135135                  interpolation_points=gauge_locations,
    136                   use_cache=True,
     136                  use_cache=False,
    137137                  verbose=True)
    138138

  • trunk/anuga_core/validation_tests/Tests/Experimental/Okushiri/produce_results.py

    r8461 r8464  
    1 #--------------------------------
    2 # Setup Default values for basis
    3 # algorithm parameters.
    4 #--------------------------------
    5 import argparse
    6 parser = argparse.ArgumentParser(description='produce results')
    7 parser.add_argument('-cfl', type=float, default=1.0,
    8                    help='cfl condition')
    9 parser.add_argument('-alg', type=str, default = "1_5",
    10                    help='flow algorithm')
    11 args = parser.parse_args()
    12 
    13 cfl = args.cfl
    14 alg = args.alg
     1from anuga.utilities.validations import run_validation_script
    152
    163
    17 
    18 import dam_break
    19 import plot_results
     4run_validation_script('create_okushiri.py')
     5run_validation_script('run_okushiri.py')
     6run_validation_script('compare_timeseries_with_measures.py')
    207
    218

  • trunk/anuga_core/validation_tests/Tests/Experimental/Okushiri/run_okushiri.py

    r8461 r8464  
    5555    domain.set_quantities_to_be_monitored('stage')
    5656
     57
     58    #------------------------------------------------------------------------------
     59    # Setup Algorithm, either using command line arguments
     60    # or override manually yourself
     61    #------------------------------------------------------------------------------
     62    from anuga.utilities.validations import validation_parse
     63    alg, cfl = validation_parse()
     64    domain.set_flow_algorithm(alg)
     65    domain.set_CFL(cfl)
     66
    5767    #-------------------------
    5868    # Boundary Conditions

  • trunk/anuga_core/validation_tests/Tests/Simple/dam_break/dam_break.py

    r8440 r8464  
    1515from time import localtime, strftime, gmtime
    1616#from balanced_dev import *
    17 
    18 
    19 #--------------------------------
    20 # Setup Default values for basic
    21 # algorithm parameters.
    22 #--------------------------------
    23 import argparse
    24 parser = argparse.ArgumentParser(description='produce results')
    25 parser.add_argument('-cfl', type=float, default=1.0,
    26                    help='cfl condition')
    27 parser.add_argument('-alg', type=str, default = "1_5",
    28                    help='flow algorithm')
    29 args = parser.parse_args()
    30 
    31 cfl = args.cfl
    32 alg = args.alg
    33 
    34 
    3517
    3618
    … …  
    6749
    6850#------------------------------------------------------------------------------
    69 # Setup Algorithm, either using command line arguments read
    70 # in earlier or manually yourself
     51# Setup Algorithm, either using command line arguments
     52# or override manually yourself
    7153#------------------------------------------------------------------------------
     54from anuga.utilities.validations import validation_parse
     55alg, cfl = validation_parse()
    7256domain.set_flow_algorithm(alg)
    7357domain.set_CFL(cfl)

  • trunk/anuga_core/validation_tests/Tests/Simple/dam_break/plot_results.py

    r8390 r8464  
    55import anuga.utilities.plot_utils as util
    66from matplotlib import pyplot as pyplot
    7 import dam_break_analytical as anal
     7import dam_break_analytical as analytic
    88
    99p_st = util.get_output('dam_break.sww')
    … …  
    1919h1 = 10.0
    2020
    21 h10,u10 = anal.vec_dam_break(p2_st.x[v2], p2_st.time[10], h0=h0, h1=h1)
    22 h50,u50 = anal.vec_dam_break(p2_st.x[v2], p2_st.time[50], h0=h0, h1=h1)
    23 h100,u100 = anal.vec_dam_break(p2_st.x[v2], p2_st.time[100], h0=h0, h1=h1)
     21h10,u10 = analytic.vec_dam_break(p2_st.x[v2], p2_st.time[10], h0=h0, h1=h1)
     22h50,u50 = analytic.vec_dam_break(p2_st.x[v2], p2_st.time[50], h0=h0, h1=h1)
     23h100,u100 = analytic.vec_dam_break(p2_st.x[v2], p2_st.time[100], h0=h0, h1=h1)
    2424
    2525pyplot.clf()
    2626pyplot.ion()
    27 pyplot.plot(p2_st.x[v2], p2_st.stage[10,v2],'b.', label='standard')
     27pyplot.plot(p2_st.x[v2], p2_st.stage[10,v2],'b.', label='numerical')
    2828pyplot.plot(p2_st.x[v2], p2_st.stage[50,v2], 'b.')
    2929pyplot.plot(p2_st.x[v2], p2_st.stage[100,v2], 'b.')
    … …  
    3333#pyplot.plot(p2_dev.x, p2_dev.stage[100,:],'b-')
    3434
    35 pyplot.plot(p2_st.x[v2], h10,'r-', label='anal')
     35pyplot.plot(p2_st.x[v2], h10,'r-', label='analytic')
    3636pyplot.plot(p2_st.x[v2], h50,'r-')
    3737pyplot.plot(p2_st.x[v2], h100,'r-')
    … …  
    4444pyplot.clf()
    4545pyplot.ion()
    46 pyplot.plot(p2_st.x[v2], p2_st.xvel[10,v2], 'b.', label='standard')
     46pyplot.plot(p2_st.x[v2], p2_st.xvel[10,v2], 'b.', label='numerical')
    4747pyplot.plot(p2_st.x[v2], p2_st.xvel[50,v2], 'b.')
    4848pyplot.plot(p2_st.x[v2], p2_st.xvel[100,v2],'b.')
    4949
    50 pyplot.plot(p2_st.x[v2], u10,'r-', label='anal')
     50pyplot.plot(p2_st.x[v2], u10,'r-', label='analytic')
    5151pyplot.plot(p2_st.x[v2], u50,'r-')
    5252pyplot.plot(p2_st.x[v2], u100,'r-')

  • trunk/anuga_core/validation_tests/Tests/Simple/dam_break/produce_results.py

    r8440 r8464  
    1 #--------------------------------
    2 # Setup Default values for basis
    3 # algorithm parameters.
    4 #--------------------------------
    5 import argparse
    6 parser = argparse.ArgumentParser(description='produce results')
    7 parser.add_argument('-cfl', type=float, default=1.0,
    8                    help='cfl condition')
    9 parser.add_argument('-alg', type=str, default = "1_5",
    10                    help='flow algorithm')
    11 args = parser.parse_args()
     1from anuga.utilities.validations import run_validation_script
    122
    13 cfl = args.cfl
    14 alg = args.alg
     3
     4run_validation_script('dam_break.py')
     5run_validation_script('plot_results.py')
    156
    167
    178
    18 import dam_break
    19 import plot_results
    209
    21 

  • trunk/anuga_core/validation_tests/Tests/Simple/deep_wave/produce_results.py

    r8440 r8464  
    1 #--------------------------------
    2 # Setup Default values for basis
    3 # algorithm parameters.
    4 #--------------------------------
    5 import argparse
    6 parser = argparse.ArgumentParser(description='produce results')
    7 parser.add_argument('-cfl', type=float, default=1.0,
    8                    help='cfl condition')
    9 parser.add_argument('-alg', type=str, default = "1_5",
    10                    help='flow algorithm')
    11 args = parser.parse_args()
    121
    13 cfl = args.cfl
    14 alg = args.alg
     2from anuga.utilities.validations import run_validation_script
    153
    164
    17 import run_wave
    18 import plotme
     5run_validation_script('run_wave.py')
     6run_validation_script('plotme.py')
     7

  • trunk/anuga_core/validation_tests/Tests/Simple/deep_wave/run_wave.py

    r8436 r8464  
    2121
    2222
     23#--------------------------------
     24# Get Default values for basic
     25# algorithm parameters.
     26#--------------------------------
     27from anuga.utilities.validations import validation_parse
     28alg, cfl = validation_parse()
    2329
    2430#-------------------------------------------------------------------------------
    … …  
    5359
    5460#------------------------------------------------------------------------------
    55 # Setup Algorithm
     61# Setup Algorithm, either using command line arguments
     62# or override manually yourself
    5663#------------------------------------------------------------------------------
    57 #domain.set_flow_algorithm(2.0)
    58 #domain.set_timestepping_method('rk2')
    59 #domain.set_default_order(2)
    60 #domain.set_beta(2.0)
    61 
    62 #print domain.get_timestepping_method()
    63 
    64 #domain.use_edge_limiter = True
    65 #domain.tight_slope_limiters = False
    66 #domain.use_centroid_velocities = False
     64from anuga.utilities.validations import validation_parse
     65alg, cfl = validation_parse()
     66domain.set_flow_algorithm(alg)
     67domain.set_CFL(cfl)
    6768
    6869

  • trunk/anuga_core/validation_tests/Tests/Simple/parabolic_basin_1D/parabolic.py

    r8429 r8464  
    55#--------
    66import anuga
    7 from anuga import *
    8 #from anuga.shallow_water.shallow_water_domain import Domain as Domain
    97import numpy
    108
    11 #from balanced_dev import *
    12 #from balanced_basic import *
    13 #from anuga.shallow_water_balanced2.swb2_domain import Domain as Domain
    14 #from anuga.shallow_water.shallow_water_domain import Domain as Domain
     9#--------------------------------
     10# Setup Default values for basic
     11# algorithm parameters.
     12#--------------------------------
     13import argparse
     14parser = argparse.ArgumentParser(description='produce results')
     15parser.add_argument('-cfl', type=float, default=1.0,
     16                   help='cfl condition')
     17parser.add_argument('-alg', type=str, default = "1_5",
     18                   help='flow algorithm')
     19args = parser.parse_args()
     20
     21cfl = args.cfl
     22alg = args.alg
     23
     24
    1525#---------
    1626#Setup computational domain
    … …  
    1828points, vertices, boundary = anuga.rectangular_cross(200,10, len1=40.0,len2=2.0)
    1929
    20 domain=Domain(points,vertices,boundary)    # Create Domain
     30domain=anuga.Domain(points,vertices,boundary)    # Create Domain
    2131domain.set_name('parabola_v2')                         # Output to file runup.sww
    2232domain.set_datadir('.')                          # Use current folder
    23 domain.set_quantities_to_be_stored({'stage': 2, 'xmomentum': 2, 'ymomentum': 2, 'elevation': 1})
    2433domain.set_minimum_allowed_height(0.01)
    25 # Time stepping
    26 #domain.set_timestepping_method('euler') # Default
    27 #domain.set_timestepping_method('rk2') #
    28 #domain.beta_w= 1. #0.2
    29 #domain.beta_uh= 1. #0.2
    30 #domain.beta_vh= 1. #0.2
    31 #domain.beta_w_dry= 0.2 #0.
    32 #domain.beta_uh_dry= 0.2 #0.
    33 #domain.beta_vh_dry= 0.2 #0.
    34 #domain.alpha=100.
     34
     35
     36#------------------------------------------------------------------------------
     37# Setup Algorithm, either using command line arguments read
     38# in earlier or manually yourself
     39#------------------------------------------------------------------------------
     40domain.set_flow_algorithm(alg)
     41domain.set_CFL(cfl)
    3542
    3643#------------------
    … …  
    7885#Evolve the system through time
    7986#------------------------------
    80 for t in domain.evolve(yieldstep=0.1,finaltime=90.0):
     87for t in domain.evolve(yieldstep=1.0,finaltime=90.0):
    8188    print domain.timestepping_statistics()
    8289

  • trunk/anuga_core/validation_tests/Tests/Simple/parabolic_basin_1D/produce_results.py

    r8440 r8464  
    1 #--------------------------------
    2 # Setup Default values for basis
    3 # algorithm parameters.
    4 #--------------------------------
    5 import argparse
    6 parser = argparse.ArgumentParser(description='produce results')
    7 parser.add_argument('-cfl', type=float, default=1.0,
    8                    help='cfl condition')
    9 parser.add_argument('-alg', type=str, default = "1_5",
    10                    help='flow algorithm')
    11 args = parser.parse_args()
    12 
    13 cfl = args.cfl
    14 alg = args.alg
     1from anuga.utilities.validations import run_validation_script
    152
    163
     4run_validation_script('parabolic.py')
     5run_validation_script('parabolaplot.py')
    176
    187
    19 import parabolic
    20 import parabolaplot

  • trunk/anuga_core/validation_tests/Tests/Simple/runup1/produce_results.py

    r8440 r8464  
    1 #--------------------------------
    2 # Setup Default values for basis
    3 # algorithm parameters.
    4 #--------------------------------
    5 import argparse
    6 parser = argparse.ArgumentParser(description='produce results')
    7 parser.add_argument('-cfl', type=float, default=1.0,
    8                    help='cfl condition')
    9 parser.add_argument('-alg', type=str, default = "1_5",
    10                    help='flow algorithm')
    11 args = parser.parse_args()
    12 
    13 cfl = args.cfl
    14 alg = args.alg
     1from anuga.utilities.validations import run_validation_script
    152
    163
     4run_validation_script('runup.py')
     5run_validation_script('runuplot.py')
    176
    18 import runup
    19 import runuplot

  • trunk/anuga_core/validation_tests/Tests/Simple/runup1/runup.py

    r8407 r8464  
    99
    1010from math import sin, pi, exp
    11 #from anuga.shallow_water_balanced2.swb2_domain import Domain as Domain
    12 from anuga.shallow_water.shallow_water_domain import Domain as Domain
    13 #from shallow_water_balanced_steve.swb_domain import *
    14 #import shallow_water_balanced_steve.swb_domain
    15 #from shallow_water_balanced_steve.swb_domain import Domain as Domain
    16 #path.append('/home/gareth/storage/anuga_clean/anuga_jan12/trunk/anuga_work/shallow_water_balanced_steve')
    17 #from swb_domain import *
    18 #path.append('/home/gareth/storage/anuga_clean/anuga_jan12/trunk/anuga_work/development/gareth/balanced_basic')
    19 #from balanced_basic import *
    20 #from balanced_dev import *
     11
     12from anuga import Domain
     13
     14
    2115#---------
    2216#Setup computational domain
    … …  
    2923domain.set_quantities_to_be_stored({'stage': 2, 'xmomentum': 2, 'ymomentum': 2, 'elevation': 1})
    3024#domain.set_store_vertices_uniquely(True)
     25
     26
     27#------------------------------------------------------------------------------
     28# Setup Algorithm, either using command line arguments
     29# or override manually yourself
     30#------------------------------------------------------------------------------
     31from anuga.utilities.validations import validation_parse
     32alg, cfl = validation_parse()
     33domain.set_flow_algorithm(alg)
     34domain.set_CFL(cfl)
     35
     36
    3137#------------------
    3238# Define topography

  • trunk/anuga_core/validation_tests/Tests/Simple/runup_sinusoid/produce_results.py

    r8412 r8464  
    1 import runup_sinusoid
    2 import runup_sinusoidplot
     1from anuga.utilities.validations import run_validation_script
     2
     3
     4run_validation_script('runup_sinusoid.py')
     5run_validation_script('runup_sinusoidplot.py')
     6
     7 

  • trunk/anuga_core/validation_tests/Tests/Simple/runup_sinusoid/runup_sinusoid.py

    r8412 r8464  
    2626#domain.set_store_vertices_uniquely(True)
    2727domain.minimum_allowed_height=0.001
     28
     29#------------------------------------------------------------------------------
     30# Setup Algorithm, either using command line arguments
     31# or override manually yourself
     32#------------------------------------------------------------------------------
     33from anuga.utilities.validations import validation_parse
     34alg, cfl = validation_parse()
     35domain.set_flow_algorithm(alg)
     36domain.set_CFL(cfl)
     37
    2838
    2939#------------------

  • trunk/anuga_core/validation_tests/Tests/Simple/steep_slope/channel_SU_2plot.py

    r8436 r8464  
    4141# Make plot animation
    4242#--------------------
    43 pyplot.close() #If the plot is open, there will be problems
     43pyplot.clf()
    4444pyplot.ion()
    4545

  • trunk/anuga_core/validation_tests/Tests/Simple/steep_slope/channel_SU_sparse.py

    r8436 r8464  
    77# Import necessary modules
    88#------------------------------------------------------------------------------
    9 # Import standard shallow water domain and standard boundaries.
    109import anuga
    1110from anuga import rectangular_cross as rectangular_cross
    1211from anuga.structures.inlet_operator import Inlet_operator
    13 from anuga import Domain as Domain
    14 #from anuga.shallow_water.shallow_water_domain import Domain as Domain
    15 #from balanced_dev import *
    16 #from balanced_dev import Domain as Domain
     12from anuga import Domain
     13
    1714#------------------------------------------------------------------------------
    1815# Setup computational domain
    … …  
    2219domain = Domain(points, vertices, boundary) # Create domain
    2320domain.set_name('channel_SU_2_v2') # Output name
    24 domain.set_store_vertices_uniquely(True)
    25 domain.set_flow_algorithm(2.0)
    26 #domain.CFL=1.0
    27 #domain.set_sloped_mannings_function()
     21
     22#------------------------------------------------------------------------------
     23# Setup Algorithm, either using command line arguments
     24# or override manually yourself
     25#------------------------------------------------------------------------------
     26from anuga.utilities.validations import validation_parse
     27alg, cfl = validation_parse()
     28domain.set_flow_algorithm(alg)
     29domain.set_CFL(cfl)
     30
    2831#------------------------------------------------------------------------------
    2932# Setup initial conditions
    … …  
    4447domain.set_quantity('friction', 0.03) # Constant friction
    4548domain.set_quantity('stage', stagetopo)
     49
    4650#------------------------------------------------------------------------------
    4751# Setup boundary conditions

  • trunk/anuga_core/validation_tests/Tests/Simple/steep_slope/produce_results.py

    r8434 r8464  
    1 import channel_SU_sparse
    2 import channel_SU_2plot
     1from anuga.utilities.validations import run_validation_script
     2
     3
     4
     5run_validation_script('channel_SU_sparse.py')
     6run_validation_script('channel_SU_2plot.py')
     7

  • trunk/anuga_core/validation_tests/Tests/Simple/trapezoidal_channel/channel_floodplain1.py

    r8427 r8464  
    1111from anuga.structures.inlet_operator import Inlet_operator
    1212from anuga import *
    13 #from swb_domain import domain
    14 #from anuga import *
    15 #from balanced_basic import *
    16 #from balanced_dev import *
    17 #from balanced_basic.swb2_domain import *
    18 #from balanced_basic.swb2_domain import Domain
     13
    1914#------------------------------------------------------------------------------
    2015# Useful parameters for controlling this case
    … …  
    8378
    8479domain.set_name('channel_floodplain1') # Output name
    85 #domain.set_store_vertices_uniquely(True)
    86 #domain.use_edge_limiter=False
    87 #domain.extrapolate_velocity_second_order=False
     80
     81#------------------------------------------------------------------------------
     82# Setup Algorithm, either using command line arguments
     83# or override manually yourself
     84#------------------------------------------------------------------------------
     85from anuga.utilities.validations import validation_parse
     86alg, cfl = validation_parse()
     87domain.set_flow_algorithm(alg)
     88domain.set_CFL(cfl)
     89
    8890#------------------------------------------------------------------------------
    8991#

  • trunk/anuga_core/validation_tests/Tests/Simple/trapezoidal_channel/produce_results.py

    r8427 r8464  
    1 import channel_floodplain1
    2 import plotme
     1from anuga.utilities.validations import run_validation_script
     2
     3
     4run_validation_script('channel_floodplain1.py')
     5run_validation_script('plotme.py')
     6
     7 

  • trunk/anuga_core/validation_tests/Tests/Simple/trapezoidal_channel/results.tex

    r8450 r8464  
    2929Table~\ref{trapztab} shows the discharge computed at 3 cross-sections in the channel, at a number of time-steps on the way to near steady-state. By the end of the simulation they should all be essentially the same. Large variations may suggest mass conservation errors (small variations are probably due to the interpolation that occurs in the 'compute\_flow\_through\_cross\_section' routine).
    3030
    31 \DTLloaddb{dischargeout}{Tests/Analytical/trapezoidal_channel/discharge_outputs.txt}
     31\DTLloaddb{dischargeout}{Tests/Simple/trapezoidal_channel/discharge_outputs.txt}
    3232\begin{table}
    3333\caption{Discharge through cross-sections at 10m, 700m, and 1000m along the channel, at different instants in time}

  • trunk/anuga_core/validation_tests/produce_results.py

    r8445 r8464  
    88import time
    99
     10from anuga.utilities.validations import validation_parse
     11
    1012#--------------------------------
    1113# Setup Default values for basis
    1214# algorithm parameters.
    1315#--------------------------------
    14 import argparse
    15 parser = argparse.ArgumentParser(description='produce results')
    16 parser.add_argument('-cfl', type=float, default=1.0,
    17                    help='cfl condition')
    18 parser.add_argument('-alg', type=str, default = "1_5",
    19                    help='flow algorithm')
    20 args = parser.parse_args()
     16alg, cfl = validation_parse()
    2117
    22 cfl = args.cfl
    23 alg = args.alg
    2418
    2519#---------------------------------
    … …  
    4943
    5044    os.chdir(dir)
    51     #print 'Changing to', os.getcwd()
     45    print 'Changing to', os.getcwd()
    5246    Lower_dirs = os.listdir('.')
    5347    try:

  • trunk/anuga_validation/analytical_solutions/circular_hydraulic_jump.py

    r7626 r8464  
    1010# Setup modules
    1111
    12 from anuga.shallow_water import Domain, Dirichlet_Discharge_boundary
    13 from anuga.shallow_water import Transmissive_Momentum_Set_Stage_boundary, Dirichlet_boundary
     12from anuga.shallow_water import Dirichlet_Discharge_boundary
     13from anuga import Domain
     14from anuga import Transmissive_Momentum_Set_Stage_boundary, Dirichlet_boundary
    1415from math import pi, sqrt
    1516from anuga.abstract_2d_finite_volumes.mesh_factory import strang_mesh
Note: See TracChangeset for help on using the changeset viewer.