source: anuga_validation/conical_island/run_circular.py @ 4783

"""Validation of the AnuGA implementation of the shallow water wave equation.

This script sets up 2D circular island.....

"""

# Module imports
from anuga.shallow_water import Domain
from anuga.shallow_water import Reflective_boundary
from anuga.shallow_water import Transmissive_Momentum_Set_Stage_boundary
from anuga.shallow_water import Dirichlet_boundary, Time_boundary
from anuga.abstract_2d_finite_volumes.util import file_function
from anuga.pmesh.mesh_interface import create_mesh_from_regions
#from cmath import cos,sin,cosh,pi
from math import cos,pi,sin,tan,sqrt
from Numeric import array, zeros, Float, allclose

#import project

#-------------------------
# Create Domain from mesh
#-------------------------


def prepare_timeboundary(filename):
    """Converting benchmark 2 time series to NetCDF tms file.
    This is a 'throw-away' code taylor made for files like
    'Benchmark_2_input.txt' from the LWRU2 benchmark
    """

    textversion = filename[:-4] + '.txt'

    print 'Preparing time boundary from %s' %textversion
    from Numeric import array

    fid = open(textversion)

    #Skip first line
    line = fid.readline()

    #Read remaining lines
    lines = fid.readlines()
    fid.close()


    N = len(lines)
    T = zeros(N, Float)  #Time
    Q = zeros(N, Float)  #Values

    for i, line in enumerate(lines):
        fields = line.split()
        print 'fields',i,line

        T[i] = float(fields[0])
        Q[i] = float(fields[1])


    #Create tms file
    from Scientific.IO.NetCDF import NetCDFFile

    print 'Writing to', filename
    fid = NetCDFFile(filename[:-4] + '.tms', 'w')

    fid.institution = 'Geoscience Australia'
    fid.description = 'Input wave for Benchmark 2'
    fid.starttime = 0.0
    fid.createDimension('number_of_timesteps', len(T))
    fid.createVariable('time', Float, ('number_of_timesteps',))
    fid.variables['time'][:] = T

    fid.createVariable('stage', Float, ('number_of_timesteps',))
    fid.variables['stage'][:] = Q[:]

    fid.createVariable('xmomentum', Float, ('number_of_timesteps',))
    fid.variables['xmomentum'][:] = 0.0

    fid.createVariable('ymomentum', Float, ('number_of_timesteps',))
    fid.variables['ymomentum'][:] = 0.0

    fid.close()




poly_all= [[0,0],[0,25],[30,25],[30,0]]
poly=[[9,10],[9,17.6],[16.6,17.6],[16.6,10]]
internal_poly=[[poly,1]]
create_mesh_from_regions(poly_all,
                         boundary_tags={'wall': [0,1,2],'wave': [3]},
                         maximum_triangle_area=10,
                         interior_regions=internal_poly,
                         filename='temp.msh',
                         use_cache=False,
                         verbose=True)

domain = Domain('temp.msh', use_cache=True, verbose=True)
print domain.statistics()

#-------------------------
# Initial Conditions
#-------------------------
domain.set_quantity('friction', 0.0)
water_height = 0.32
domain.set_quantity('stage', water_height)

def test():                
    fileName = "test.csv"
    file = open(fileName,"w")
    file.write("x,y,elevation \n")
    x = 12.96
    y = 13.80
    for i in range(0,30):
        for j in range(0,25):
            a = (x-i)**2
            b = (y-j)**2
            z = -sqrt((x-i)**2+(y-j)**2)
            z = z*.25+(0.8975)
            if z <0:
                z=0
            if z > .625:
                z=0.625

            print 'x,y,f',i,j,a,b,z
            file.write("%s, %s, %s\n" %(i, j, z))
    file.close()

test()

domain.set_quantity('elevation',filename = "test.csv", alpha=0.1)


#-------------------------
# Set simulation parameters
#-------------------------
domain.set_name('test')  # Name of output sww file
domain.set_default_order(1)               # Apply second order scheme 
domain.set_all_limiters(0.9)              # Max second order scheme (old lim)
domain.set_minimum_storable_height(0.01) # Don't store w < 0.001m
domain.set_maximum_allowed_speed(0.1)     # Allow a little runoff (0.1 is OK)
domain.tight_slope_limiters = 1
domain.beta_h = 0.0

#Timings on AMD64-242 (beta_h=0)
#  tight_slope_limiters = 0:
#    3035s - 3110s
#  tight_slope_limiters = 1:
#    3000s - 3008s
#
# beta_h>0: In the order of 3200s

#-------------------------
# Boundary Conditions
#-------------------------

# Create boundary function from timeseries provided in file
#function = file_function(project.boundary_filename,
#                         domain, verbose=True)
def waveform(t): 
        return (sin(t*2*pi))

# Create and assign boundary objects
boundary_filename="ts2a_edit_input_32"
prepare_timeboundary(boundary_filename+'.txt')

function = file_function(boundary_filename+'.tms',
                         domain, verbose=True)

# Create and assign boundary objects
Bts = Transmissive_Momentum_Set_Stage_boundary(domain, function)

#Bts = Transmissive_Momentum_Set_Stage_boundary(domain, waveform)
Bw = Time_boundary(domain=domain,
                   f=lambda t: [(0.1*sin(t*2*pi)), 0.0, 0.0])
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([water_height,0,0])
domain.set_boundary({'wave': Bts, 'wall': Bd})

#-------------------------
# Evolve through time
#-------------------------
import time
t0 = time.time()

for t in domain.evolve(yieldstep = 5, finaltime = 75):
    domain.write_time()
#    domain.write_time(track_speeds=False)

print 'That took %.2f seconds' %(time.time()-t0)