def concept_ungenerateIII(self):
from anuga import Domain, Reflective_boundary, \
Dirichlet_boundary
from anuga.pmesh.mesh_interface import create_mesh_from_regions
# These are the absolute values
polygon = [[0,0], [100,0], [100,100], [0,100]]
boundary_tags = {'wall': [0,1,3], 'wave': [2]}
inner1_polygon = [[10,10], [20,10], [20,20], [10,20]]
inner2_polygon = [[30,30], [40,30], [40,40], [30,40]]
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions)
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName)
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'mesh.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache=False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
def concept_ungenerateIII(self):
from anuga import Domain, Reflective_boundary, \
Dirichlet_boundary
from anuga.pmesh.mesh_interface import create_mesh_from_regions
# These are the absolute values
polygon = [[0, 0], [100, 0], [100, 100], [0, 100]]
boundary_tags = {'wall': [0, 1, 3], 'wave': [2]}
inner1_polygon = [[10, 10], [20, 10], [20, 20], [10, 20]]
inner2_polygon = [[30, 30], [40, 30], [40, 40], [30, 40]]
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions)
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName)
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'mesh.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache=False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
##vis.start()
#===============================================================================
if myid == 0:
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
parameter_file=open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep = 1000., finaltime = 30000.):
#print domain.timestepping_statistics(track_speeds=True)
if myid == 0 and verbose:
print domain.timestepping_statistics()
#vis.update()
domain.sww_merge(delete_old=True)
finalize()
#----------------------------------------------
# Associate boundary tags with boundary objects
#----------------------------------------------
domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom': Br})
#------------------------------
#Evolve the system through time
#------------------------------
#xwrite=open("xvel.out","wb")
#ywrite=open("yvel.out","wb")
## Set print options to be compatible with file writing via the 'print' statement
#numpy.set_printoptions(threshold=numpy.nan, linewidth=numpy.nan)
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file = open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(), parameter_file, indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
for t in domain.evolve(yieldstep=0.2, finaltime=30.0):
if myid == 0 and verbose: print(domain.timestepping_statistics())
domain.sww_merge(delete_old=True)
finalize()
def sequential_time_varying_file_boundary_sts(self):
"""sequential_ltest_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts.
"""
lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]]
bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0],
[6.02,97.02],[6.00,97.02]]
tide = 3.0
time_step_count = 65
time_step = 2.
n=len(lat_long_points)
first_tstep=num.ones(n,num.int)
last_tstep=(time_step_count)*num.ones(n,num.int)
finaltime=num.float(time_step*(time_step_count-1))
yieldstep=num.float(time_step)
gauge_depth=20*num.ones(n,num.float)
ha=2*num.ones((n,time_step_count),num.float)
ua=10*num.ones((n,time_step_count),num.float)
va=-10*num.ones((n,time_step_count),num.float)
times=num.arange(0., num.float(time_step_count*time_step), time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i]+=times/finaltime
sts_file="test"
if myid==0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d=","
order_file=order_base_name+'order.txt'
fid=open(order_file,'w')
# Write Header
header='index, longitude, latitude\n'
fid.write(header)
indices=[3,0,1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert(os.access(sts_file+'.sts', os.F_OK))
os.remove(order_file)
barrier()
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm=[]
for point in bounding_polygon:
zone,easting,northing=redfearn(point[0],point[1])
bounding_polygon_utm.append([easting,northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm,boundary_polygon)
extent_res=1000000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions=None
boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]}
# have to change boundary tags from last example because now bounding
# polygon starts in different place.
if myid==0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
if verbose: print "Creating file boundary condition"
Bf = File_boundary(sts_file+'.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br})
temp_fbound=num.zeros(int(finaltime/yieldstep)+1,num.float)
if verbose: print "Evolving domain with file boundary condition"
for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
temp_fbound[i]=domain_fbound.quantities['stage'].centroid_values[2]
if verbose: domain_fbound.write_time()
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(domain=domain_drchlt, f=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime])
#Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
temp_drchlt=num.zeros(int(finaltime/yieldstep)+1,num.float)
for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
temp_drchlt[i]=domain_drchlt.quantities['stage'].centroid_values[2]
#domain_drchlt.write_time()
#print domain_fbound.quantities['stage'].vertex_values
#print domain_drchlt.quantities['stage'].vertex_values
assert num.allclose(temp_fbound,temp_drchlt),temp_fbound-temp_drchlt
assert num.allclose(domain_fbound.quantities['stage'].vertex_values,
domain_drchlt.quantities['stage'].vertex_values)
assert num.allclose(domain_fbound.quantities['xmomentum'].vertex_values,
domain_drchlt.quantities['xmomentum'].vertex_values)
assert num.allclose(domain_fbound.quantities['ymomentum'].vertex_values,
domain_drchlt.quantities['ymomentum'].vertex_values)
if not sys.platform == 'win32':
if myid==0: os.remove(sts_file+'.sts')
if myid==0: os.remove(meshname)
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file = open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(), parameter_file, indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=10.0, finaltime=3000.0):
if myid == 0 and verbose: print domain.timestepping_statistics()
#print (stage-elev).get_integral()
#print (domain.areas*(domain.quantities['stage'].centroid_values - domain.quantities['elevation'].centroid_values)).sum()
#s3 = domain.get_flow_through_cross_section([[30., 0.0], [30., 100.]])
#s4 = domain.get_flow_through_cross_section([[32., 0.0], [32., 100.]])
#s5 = domain.get_flow_through_cross_section([[34., 0.0], [34., 100.]])
#s2 = domain.get_flow_through_cross_section([[45., 0.0], [45., 100.]])
#s1 = domain.get_flow_through_cross_section([[53., 0.0], [53., 100.]])
#s0 = domain.get_flow_through_cross_section([[60., 0.0], [60., 100.]])
#print 'Xsectional flow:', s0, s1, s2, s3, s4, s5
domain.sww_merge(delete_old=True)
finalize()
# create parallel domain
#===================================================================================
domain = distribute(domain)
#-----------------------------------------------------------------------------
# Setup boundary conditions
#------------------------------------------------------------------------------
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
Bd = anuga.Dirichlet_boundary([1, 0., 0.]) # Constant boundary values
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Bt, 'right': Bt, 'top': Br, 'bottom': Br})
#-------------------------------------------------------------------------
# Produce a documentation of parameters
#-------------------------------------------------------------------------
from anuga.validation_utilities import save_parameters_tex
save_parameters_tex(domain)
#===================================================================================
# Evolve system through time
#===================================================================================
for t in domain.evolve(yieldstep=0.5, finaltime=50.):
if myid == 0 and verbose:
print domain.timestepping_statistics()
domain.sww_merge(delete_old=True)
finalize()
return [wO, pO, 0.0] # dimensional
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
#Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values
BTime = anuga.Time_boundary(domain,f_CG)
# Associate boundary tags with boundary objects
domain.set_boundary({'left': BTime, 'right': Bt, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file=open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep = Tp/48., finaltime = 7000.):
if myid == 0 and verbose: print domain.timestepping_statistics()
domain.sww_merge(delete_old=True)
finalize()
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
polygon1 = [ [10.0, 0.0], [11.0, 0.0], [11.0, 5.0], [10.0, 5.0] ]
polygon2 = [ [12.0, 2.0], [13.0, 2.0], [13.0, 3.0], [12.0, 3.0] ]
from anuga.operators.rate_operators import Rate_operator
op1 = Rate_operator(domain, rate=lambda t: 10.0 if (t>=0.0) else 0.0, polygon=polygon2)
op2 = Rate_operator(domain, rate=lambda t: 10.0 if (t>=0.0) else 0.0, radius=0.5, center=(10.0, 3.0))
domain.set_starttime(-0.1)
for t in domain.evolve(yieldstep=0.01, finaltime=0.0):
domain.print_timestepping_statistics()
domain.print_operator_timestepping_statistics()
stage = domain.get_quantity('stage')
elev = domain.get_quantity('elevation')
height = stage - elev
print 'integral = ', height.get_integral()
for t in domain.evolve(yieldstep=0.1, duration=5.0):
domain.print_timestepping_statistics()
domain.print_operator_timestepping_statistics()
def start_sim(run_id, Runs, scenario_name, Scenario, session, **kwargs):
yieldstep = kwargs['yieldstep']
finaltime = kwargs['finaltime']
logger = logging.getLogger(run_id)
max_triangle_area = kwargs['max_triangle_area']
logger.info('Starting hydrata_project')
if run_id == 'local_run':
base_dir = os.getcwd()
else:
base_dir = os.getcwd() + '/base_dir/%s/' % run_id
outname = run_id
meshname = base_dir + 'outputs/' + run_id + '.msh'
def get_filename(data_type, file_type):
files = os.listdir('%sinputs/%s' % (base_dir, data_type))
filename = '%sinputs/%s/%s' % (
base_dir, data_type, [f for f in files if f[-4:] == file_type][0])
return filename
boundary_data_filename = get_filename('boundary_data', '.shp')
elevation_data_filename = get_filename('elevation_data', '.tif')
try:
structures_filename = get_filename('structures', '.shp')
except OSError as e:
structures_filename = None
try:
rain_data_filename = get_filename('rain_data', '.shp')
except OSError as e:
rain_data_filename = None
try:
inflow_data_filename = get_filename('inflow_data', '.shp')
except OSError as e:
inflow_data_filename = None
try:
friction_data_filename = get_filename('friction_data', '.shp')
except OSError as e:
friction_data_filename = None
logger.info('boundary_data_filename: %s' % boundary_data_filename)
logger.info('structures_filename: %s' % structures_filename)
logger.info('rain_data_filename: %s' % rain_data_filename)
logger.info('inflow_data_filename: %s' % inflow_data_filename)
logger.info('friction_data_filename: %s' % friction_data_filename)
logger.info('elevation_data_filename: %s' % elevation_data_filename)
# create a list of project files
vector_filenames = [
boundary_data_filename, structures_filename, rain_data_filename,
inflow_data_filename, friction_data_filename
]
# set the projection system for ANUGA calculations from the geotiff elevation data
elevation_data_gdal = gdal.Open(elevation_data_filename)
project_spatial_ref = osr.SpatialReference()
project_spatial_ref.ImportFromWkt(elevation_data_gdal.GetProjectionRef())
project_spatial_ref_epsg_code = int(
project_spatial_ref.GetAttrValue("AUTHORITY", 1))
# check the spatial reference system of the project files matches that of the calculation
for filename in vector_filenames:
if filename:
prj_text = open(filename[:-4] + '.prj').read()
srs = osr.SpatialReference()
srs.ImportFromESRI([prj_text])
srs.AutoIdentifyEPSG()
logger.info('filename is: %s' % filename)
logger.info('EPSG is: %s' % srs.GetAuthorityCode(None))
if str(srs.GetAuthorityCode(None)) != str(
project_spatial_ref_epsg_code):
logger.warning('warning spatial refs are not maching: %s, %s' %
(srs.GetAuthorityCode(None),
project_spatial_ref_epsg_code))
logger.info('Setting up structures...')
if structures_filename:
structures = []
logger.info('processing structures from :%s' % structures_filename)
ogr_shapefile = ogr.Open(structures_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
structure = json.loads(ogr_layer_feature.GetGeometryRef().
ExportToJson())['coordinates'][0]
structures.append(structure)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
logger.info('structures: %s' % structures)
else:
logger.warning('warning: no structures found.')
structures = None
logger.info('Setting up friction...')
frictions = []
if friction_data_filename:
logger.info('processing frictions from :%s' % friction_data_filename)
ogr_shapefile = ogr.Open(friction_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
friction_poly = json.loads(ogr_layer_feature.GetGeometryRef().
ExportToJson())['coordinates'][0]
friction_value = float(ogr_layer_feature.GetField('mannings'))
friction_couple = [friction_poly, friction_value]
frictions.append(friction_couple)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
frictions.append(['All', 0.04])
logger.info('frictions: %s' % frictions)
else:
frictions.append(['All', 0.04])
logger.info('warning: no frictions found.')
logger.info('Setting up boundary conditions...')
ogr_shapefile = ogr.Open(boundary_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_definition = ogr_layer.GetLayerDefn()
logger.info('ogr_layer_definition.GetGeomType: %s' %
ogr_layer_definition.GetGeomType())
boundary_tag_index = 0
bdy_tags = {}
bdy = {}
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
boundary_tag_key = ogr_layer_feature.GetField('bdy_tag_k')
boundary_tag_value = ogr_layer_feature.GetField('bdy_tag_v')
bdy_tags[boundary_tag_key] = [
boundary_tag_index * 2, boundary_tag_index * 2 + 1
]
bdy[boundary_tag_key] = boundary_tag_value
geom = ogr_layer_feature.GetGeometryRef().GetPoints()
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
boundary_tag_index = boundary_tag_index + 1
logger.info('bdy_tags: %s' % bdy_tags)
logger.info('bdy: %s' % bdy)
boundary_data = su.read_polygon(boundary_data_filename)
create_mesh_from_regions(boundary_data,
boundary_tags=bdy_tags,
maximum_triangle_area=max_triangle_area,
interior_regions=None,
interior_holes=structures,
filename=meshname,
use_cache=False,
verbose=True)
domain = Domain(meshname, use_cache=False, verbose=True)
domain.set_name(outname)
domain.set_datadir(base_dir + '/outputs')
logger.info(domain.statistics())
poly_fun_pairs = [['Extent', elevation_data_filename.encode("utf-8")]]
topography_function = qs.composite_quantity_setting_function(
poly_fun_pairs,
domain,
nan_treatment='exception',
)
friction_function = qs.composite_quantity_setting_function(
frictions, domain)
domain.set_quantity('friction', friction_function, verbose=True)
domain.set_quantity('stage', 0.0)
domain.set_quantity('elevation',
topography_function,
verbose=True,
alpha=0.99)
domain.set_minimum_storable_height(0.005)
logger.info('Applying rainfall...')
if rain_data_filename:
ogr_shapefile = ogr.Open(rain_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
rainfall = 0
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
rainfall = float(ogr_layer_feature.GetField('rate_mm_hr'))
polygon = su.read_polygon(rain_data_filename)
logger.info("applying Polygonal_rate_operator with rate, polygon:")
logger.info(rainfall)
logger.info(polygon)
Polygonal_rate_operator(domain,
rate=rainfall,
factor=1.0e-6,
polygon=polygon,
default_rate=0.0)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
logger.info('Applying surface inflows...')
if inflow_data_filename:
ogr_shapefile = ogr.Open(inflow_data_filename)
ogr_layer = ogr_shapefile.GetLayer(0)
ogr_layer_definition = ogr_layer.GetLayerDefn()
ogr_layer_feature = ogr_layer.GetNextFeature()
while ogr_layer_feature:
in_fixed = float(ogr_layer_feature.GetField('in_fixed'))
line = ogr_layer_feature.GetGeometryRef().GetPoints()
logger.info("applying Inlet_operator with line, in_fixed:")
logger.info(line)
logger.info(in_fixed)
Inlet_operator(domain, line, in_fixed, verbose=False)
ogr_layer_feature = None
ogr_layer_feature = ogr_layer.GetNextFeature()
logger.info('Applying Boundary Conditions...')
logger.info('Available boundary tags: %s' % domain.get_boundary_tags())
Br = anuga.Reflective_boundary(domain)
Bd = anuga.Dirichlet_boundary([0.0, 0.0, 0.0])
Bt = anuga.Transmissive_boundary(domain)
for key, value in bdy.iteritems():
if value == 'Br':
bdy[key] = Br
elif value == 'Bd':
bdy[key] = Bd
elif value == 'Bt':
bdy[key] = Bt
else:
logger.info(
'No matching boundary condition exists - please check your shapefile attributes in: %s'
% boundary_data_filename)
# set a default value for exterior & interior boundary if it is not already set
try:
bdy['exterior']
except KeyError:
bdy['exterior'] = Br
try:
bdy['interior']
except KeyError:
bdy['interior'] = Br
logger.info('bdy: %s' % bdy)
domain.set_boundary(bdy)
domain = distribute(domain)
logger.info('Beginning evolve phase...')
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
print domain.timestepping_statistics()
logger.info(domain.timestepping_statistics(track_speeds=True))
percentage_complete = round(domain.time / domain.finaltime, 3) * 100
logger.info('%s percent complete' % percentage_complete)
if run_id != 'local_run':
write_percentage_complete(run_id, Runs, scenario_name, Scenario,
session, percentage_complete)
domain.sww_merge(delete_old=True)
barrier()
finalize()
sww_file = base_dir + '/outputs/' + run_id + '.sww'
sww_file = sww_file.encode(
'utf-8',
'ignore') # sometimes run_id gets turned to a unicode object by celery
util.Make_Geotif(swwFile=sww_file,
output_quantities=['depth', 'velocity'],
myTimeStep='max',
CellSize=max_triangle_area,
lower_left=None,
upper_right=None,
EPSG_CODE=project_spatial_ref_epsg_code,
proj4string=None,
velocity_extrapolation=True,
min_allowed_height=1.0e-05,
output_dir=(base_dir + '/outputs/'),
bounding_polygon=boundary_data,
internal_holes=structures,
verbose=False,
k_nearest_neighbours=3,
creation_options=[])
logger.info("Done. Nice work.")
superlink = SuperLink(superlinks, superjunctions, internal_links=20)
surface_elev = np.array([12.4, 12.2]) - 0.01
input_velocity = 1
dt = 1 # yield step
ft = 4000 # final timestep
H_js = []
losses = []
Q_iks = []
Q_uks = []
Q_dks = []
for t in domain.evolve(yieldstep=dt, finaltime=ft):
print('\n')
domain.print_timestepping_statistics()
anuga_depths = np.array([
inlet1_anuga_inlet_op.inlet.get_average_depth(),
outlet_anuga_inlet_op.inlet.get_average_depth()
])
# Compute inflow/outflow to sewer
C_o = 0.67
A_o = 2 * np.pi
Q_in = C_o * A_o * np.sign(anuga_depths -
(superlink.H_j - superlink._z_inv_j)) * np.sqrt(
np.abs(anuga_depths - (superlink.H_j -
superlink._z_inv_j)))
def parallel_time_varying_file_boundary_sts(self):
""" parallel_test_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary.
The boundary is time varying. Compares sequential result with
distributed result found using anuga_parallel
"""
#------------------------------------------------------------
# Define test variables
#------------------------------------------------------------
lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9],
[6.0, 97.0]]
bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0],
[6.02, 97.02], [6.00, 97.02]]
tide = 3.0
time_step_count = 65
time_step = 2
n = len(lat_long_points)
first_tstep = num.ones(n, num.int)
last_tstep = (time_step_count) * num.ones(n, num.int)
finaltime = num.float(time_step * (time_step_count - 1))
yieldstep = num.float(time_step)
gauge_depth = 20 * num.ones(n, num.float)
ha = 2 * num.ones((n, time_step_count), num.float)
ua = 10 * num.ones((n, time_step_count), num.float)
va = -10 * num.ones((n, time_step_count), num.float)
times = num.arange(0, time_step_count * time_step, time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i] += times / finaltime
#------------------------------------------------------------
# Write mux data to file then convert to sts format
#------------------------------------------------------------
sts_file = "test"
if myid == 0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d = ","
order_file = order_base_name + 'order.txt'
fid = open(order_file, 'w')
# Write Header
header = 'index, longitude, latitude\n'
fid.write(header)
indices = [3, 0, 1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert (os.access(sts_file + '.sts', os.F_OK))
os.remove(order_file)
barrier()
#------------------------------------------------------------
# Define boundary_polygon on each processor. This polygon defines the
# urs boundary and lies on a portion of the bounding_polygon
#------------------------------------------------------------
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm = []
for point in bounding_polygon:
zone, easting, northing = redfearn(point[0], point[1])
bounding_polygon_utm.append([easting, northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm, boundary_polygon)
extent_res = 10000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions = None
boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]}
#------------------------------------------------------------
# Create mesh on the master processor and store in file. This file
# is read in by each slave processor when needed
#------------------------------------------------------------
if myid == 0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
# barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
# print domain_fbound.mesh.get_boundary_polygon()
else:
domain_fbound = None
barrier()
if (verbose and myid == 0):
print 'DISTRIBUTING PARALLEL DOMAIN'
domain_fbound = distribute(domain_fbound)
#--------------------------------------------------------------------
# Find which sub_domain in which the interpolation points are located
#
# Sometimes the interpolation points sit exactly
# between two centroids, so in the parallel run we
# reset the interpolation points to the centroids
# found in the sequential run
#--------------------------------------------------------------------
interpolation_points = [[279000, 664000], [280250, 664130],
[279280, 665400], [280500, 665000]]
interpolation_points = num.array(interpolation_points)
#if myid==0:
# import pylab as P
# boundary_polygon=num.array(boundary_polygon)
# P.plot(boundary_polygon[:,0],boundary_polygon[:,1])
# P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko')
# P.show()
fbound_gauge_values = []
fbound_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
fbound_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_fbound.get_triangle_containing_point(point)
if domain_fbound.tri_full_flag[k] == 1:
fbound_proc_tri_ids.append(k)
else:
fbound_proc_tri_ids.append(-1)
except:
fbound_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' % (myid, fbound_proc_tri_ids)
#------------------------------------------------------------
# Set boundary conditions
#------------------------------------------------------------
Bf = File_boundary(sts_file + '.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br})
#------------------------------------------------------------
# Evolve the domain on each processor
#------------------------------------------------------------
for i, t in enumerate(
domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
stage = domain_fbound.get_quantity('stage')
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i].append(
stage.centroid_values[fbound_proc_tri_ids[i]])
#------------------------------------------------------------
# Create domain to be run sequntially on each processor
#------------------------------------------------------------
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(
domain=domain_drchlt,
function=lambda t: [
2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t /
finaltime, -220. - 10. * tide - 10. * t / finaltime
])
#Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br})
drchlt_gauge_values = []
drchlt_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
drchlt_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_drchlt.get_triangle_containing_point(point)
if domain_drchlt.tri_full_flag[k] == 1:
drchlt_proc_tri_ids.append(k)
else:
drchlt_proc_tri_ids.append(-1)
except:
drchlt_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' % (myid, drchlt_proc_tri_ids)
#------------------------------------------------------------
# Evolve entire domain on each processor
#------------------------------------------------------------
for i, t in enumerate(
domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
stage = domain_drchlt.get_quantity('stage')
for i in range(4):
drchlt_gauge_values[i].append(
stage.centroid_values[drchlt_proc_tri_ids[i]])
#------------------------------------------------------------
# Compare sequential values with parallel values
#------------------------------------------------------------
barrier()
success = True
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i] = num.array(fbound_gauge_values[i])
drchlt_gauge_values[i] = num.array(drchlt_gauge_values[i])
#print i,fbound_gauge_values[i][4]
#print i,drchlt_gauge_values[i][4]
success = success and num.allclose(fbound_gauge_values[i],
drchlt_gauge_values[i])
assert success #, (fbound_gauge_values[i]-drchlt_gauge_values[i])
#assert_(success)
if not sys.platform == 'win32':
if myid == 0: os.remove(sts_file + '.sts')
if myid == 0: os.remove(meshname)
def sequential_time_varying_file_boundary_sts(self):
"""sequential_ltest_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary. The boundary is time varying. FIXME add to test_urs2sts.
"""
lat_long_points = [[6.01, 97.0], [6.02, 97.0], [6.05, 96.9],
[6.0, 97.0]]
bounding_polygon = [[6.0, 97.0], [6.01, 97.0], [6.02, 97.0],
[6.02, 97.02], [6.00, 97.02]]
tide = 3.0
time_step_count = 65
time_step = 2.
n = len(lat_long_points)
first_tstep = num.ones(n, num.int)
last_tstep = (time_step_count) * num.ones(n, num.int)
finaltime = num.float(time_step * (time_step_count - 1))
yieldstep = num.float(time_step)
gauge_depth = 20 * num.ones(n, num.float)
ha = 2 * num.ones((n, time_step_count), num.float)
ua = 10 * num.ones((n, time_step_count), num.float)
va = -10 * num.ones((n, time_step_count), num.float)
times = num.arange(0., num.float(time_step_count * time_step),
time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i] += times / finaltime
sts_file = "test"
if myid == 0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d = ","
order_file = order_base_name + 'order.txt'
fid = open(order_file, 'w')
# Write Header
header = 'index, longitude, latitude\n'
fid.write(header)
indices = [3, 0, 1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert (os.access(sts_file + '.sts', os.F_OK))
os.remove(order_file)
barrier()
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm = []
for point in bounding_polygon:
zone, easting, northing = redfearn(point[0], point[1])
bounding_polygon_utm.append([easting, northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm, boundary_polygon)
extent_res = 1000000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions = None
boundary_tags = {'ocean': [0, 1], 'otherocean': [2, 3, 4]}
# have to change boundary tags from last example because now bounding
# polygon starts in different place.
if myid == 0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
if verbose: print "Creating file boundary condition"
Bf = File_boundary(sts_file + '.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf, 'otherocean': Br})
temp_fbound = num.zeros(int(finaltime / yieldstep) + 1, num.float)
if verbose: print "Evolving domain with file boundary condition"
for i, t in enumerate(
domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
temp_fbound[i] = domain_fbound.quantities['stage'].centroid_values[
2]
if verbose: domain_fbound.write_time()
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(
domain=domain_drchlt,
f=lambda t: [
2.0 + t / finaltime + tide, 220. + 10. * tide + 10. * t /
finaltime, -220. - 10. * tide - 10. * t / finaltime
])
#Bd = Time_boundary(domain=domain_drchlt,f=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd, 'otherocean': Br})
temp_drchlt = num.zeros(int(finaltime / yieldstep) + 1, num.float)
for i, t in enumerate(
domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step=False)):
temp_drchlt[i] = domain_drchlt.quantities['stage'].centroid_values[
2]
#domain_drchlt.write_time()
#print domain_fbound.quantities['stage'].vertex_values
#print domain_drchlt.quantities['stage'].vertex_values
assert num.allclose(temp_fbound,
temp_drchlt), temp_fbound - temp_drchlt
assert num.allclose(domain_fbound.quantities['stage'].vertex_values,
domain_drchlt.quantities['stage'].vertex_values)
assert num.allclose(
domain_fbound.quantities['xmomentum'].vertex_values,
domain_drchlt.quantities['xmomentum'].vertex_values)
assert num.allclose(
domain_fbound.quantities['ymomentum'].vertex_values,
domain_drchlt.quantities['ymomentum'].vertex_values)
if not sys.platform == 'win32':
if myid == 0: os.remove(sts_file + '.sts')
if myid == 0: os.remove(meshname)
# Setup boundary conditions
#------------------------------------------------------------------------------
Bt = anuga.Transmissive_boundary(domain)
BdIN = anuga.Dirichlet_boundary([dana, fluxin, 0.0])
#BdOUT = anuga.Dirichlet_boundary([dana-10., fluxin, 0.0])
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
domain.set_boundary({'left': BdIN, 'right': Bt, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file=open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=2.0, finaltime=200.0):
if myid ==0 and verbose: print domain.timestepping_statistics()
domain.sww_merge(delete_old=True)
finalize()
# Setup boundary conditions
#------------------------------------------------------------------------------
from math import sin, pi, exp
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
#-------------------------------------------------------------------------
# Produce a documentation of parameters
#-------------------------------------------------------------------------
from anuga.validation_utilities import save_parameters_tex
save_parameters_tex(domain)
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep = 0.05, finaltime = 3.0):
if myid == 0 and verbose:
print domain.timestepping_statistics()
domain.sww_merge(delete_old=True)
finalize()
#------------------------------------------------------------------------------
# APPLY FLOW
#------------------------------------------------------------------------------
line = [[296669.258, 6179974.191], [296677.321, 6179976.449]]
anuga.parallel.Inlet_operator(domain, line, 1.0)
#------------------------------------------------------------------------------
# SETUP BOUNDARY CONDITIONS
#------------------------------------------------------------------------------
print('Available boundary tags', domain.get_boundary_tags())
Br = anuga.Reflective_boundary(domain)
Bd = anuga.Dirichlet_boundary([0, 0, 0])
domain.set_boundary({'west': Bd, 'south': Br, 'north': Bd, 'east': Bd})
#------------------------------------------------------------------------------
# EVOLVE SYSTEM THROUGH TIME
#------------------------------------------------------------------------------
import time
t0 = time.time()
for t in domain.evolve(yieldstep=1, finaltime=4000):
print(domain.timestepping_statistics())
print(domain.boundary_statistics(quantities='stage'))
print('Finished')
# type, area, length, orifice_coeff, free_weir_coeff, submerged_weir_coeff
nodes[0].create_opening(4, 1.0, 1.0, 0.6, 1.6, 1.0)
nodes[0].coupling_area = 1.0
# TODO: setup the outlet node
nodes[1].create_opening(4, 1.0, 1.0, 0.6, 1.6, 1.0)
print("node1_is_open?:",nodes[1].is_coupled)
flow = 1.0
stop_release_water_time = 2 # the time for stopping releasing the water
domain.set_name("anuga_swmm")
for t in domain.evolve(yieldstep=1.0, finaltime=60.0):
print("\n")
#print(f"coupling step: {t}")
domain.print_timestepping_statistics()
if t < stop_release_water_time:
# assume we need to release the water into the domain for first two seconds
pass
#op_inlet.set_rate(flow)
else:
# set the overland_depth
# TODO: set up the overland depth, modify this function
print("total volume: ",domain.get_water_volume())
volumes = sim.coupling_step(1.0)
print(volumes)
region1 = Region(domain,radius = 1.0, center = (10.0, 3.0))
if isinstance(region1, Region):
op2.region = region1
else:
op2.region = Region(domain, poly=region1, expand_polygon=True)
if isinstance(polygon1, Region):
op1.region = polygon1
else:
op1.region = Region(domain, poly=polygon1, expand_polygon=True)
from self_try import get_circumference_indices
polygon11 = [ [10.0, 0.2], [11.0, 0.2], [11.0, 4.8], [10.0, 4.8] ]
for t in domain.evolve(yieldstep=0.3, finaltime=1.0):
print("domain.parallel:", domain.parallel)
op2.set_rate(dyn_t(t))
op1.set_rate(dyn_t(t))
domain.print_timestepping_statistics()
domain.print_operator_timestepping_statistics()
stage = domain.get_quantity('stage')
elev = domain.get_quantity('elevation')
height = stage - elev
#print ('integral = ', height.get_integral())
#print("st",stage)
#print("stages",op2.stage_c[:].take([op2.region.indices]))# num is the specific triangle indice
print("stages_length",len(op2.stage_c[:].take([op2.region.indices])[0]))
print("stages_length111", len(op1.stage_c[:].take([op1.region.indices])[0]))
factor = 1e-3
op3 = Rate_operator(domain, rate = rain, factor=factor)
Q3 = numpy.sum(op3.get_spatial_rate()*domain.areas)*factor
#op3()
#domain.fractional_step_operators.remove(op3)
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
accum = 0.0
yieldstep = 0.1
finaltime = 5.0
for t in domain.evolve(yieldstep=yieldstep, finaltime=finaltime):
domain.print_timestepping_statistics()
domain.print_operator_timestepping_statistics()
stage = domain.get_quantity('stage')
elev = domain.get_quantity('elevation')
height = stage - elev
print indent + 'Integral = ', height.get_integral()
print indent + 'Exact accumultion = ', accum
dd = max(min(yieldstep,4.0-t),0.0)
accum += (Q1+Q2)*yieldstep + dd*Q3
Br = anuga.Reflective_boundary(domain) # Solid reflective wall
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
#Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values
#BTime = anuga.Transmissive_n_momentum_zero_t_momentum_set_stage_boundary(domain, f_CG)
BTime = anuga.Time_boundary(domain, f_CG)
# Associate boundary tags with boundary objects
domain.set_boundary({'left': BTime, 'right': Bt, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file = open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(), parameter_file, indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=Tp / 48., finaltime=30 * Tp):
if myid == 0 and verbose: print(domain.timestepping_statistics())
domain.sww_merge(delete_old=True)
finalize()
Bw5 = anuga.Flather_external_stage_zero_velocity_boundary(domain, zero_fun)
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Bw2, 'right': Bw5, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file=open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep = 10, finaltime = 2e4):
domain.write_time()
if interactive_visualisation:
vis.update()
domain.sww_merge(delete_old=True)
finalize()
#------------------------------------------------------------------------------
# Setup operators
#------------------------------------------------------------------------------
from anuga.operators.vegetation_operator import Vegetation_operator
veg_op = Vegetation_operator(domain)
Quantity(domain, name='veg_diameter', register=True)
domain.set_quantity('veg_diameter', 0.00064)
Quantity(domain, name='veg_spacing', register=True)
domain.set_quantity('veg_spacing', 0.15)
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep = 1, finaltime = 30.0):
domain.print_timestepping_statistics()
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Bd, 'right': Bd, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file=open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep = 1.0, finaltime = 20.):
#print domain.timestepping_statistics(track_speeds=True)
if myid == 0 and verbose: print domain.timestepping_statistics()
domain.sww_merge(delete_old=True)
finalize()
def concept_ungenerateII(self):
from anuga import Domain, Reflective_boundary, Dirichlet_boundary
x=0
y=0
mesh_geo = geo_reference=Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0,0], [100,0], [100,100], [0,100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'wall': [0,1,3], 'wave': [2]}
inner1_polygon_absolute = [[10,10], [20,10], [20,20], [10,20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30,30], [40,30], [40,40], [30,40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo)
m.export_mesh_file('a_test_mesh_iknterface.tsh')
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName) #, tag='wall')
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'bento_b.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache = False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
Bt = anuga.Transmissive_boundary(domain) # Continue all values on boundary
BdL = anuga.Dirichlet_boundary([0.41373588752426715, 0.18,
0.]) # Constant boundary values
BdR = anuga.Dirichlet_boundary([0.33, 0.18, 0.]) # Constant boundary values
# Associate boundary tags with boundary objects
domain.set_boundary({'left': BdL, 'right': BdR, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file = open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(), parameter_file, indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=1.0, finaltime=100.):
#print(domain.timestepping_statistics(track_speeds=True))
if myid == 0 and verbose: print(domain.timestepping_statistics())
#vis.update()
domain.sww_merge(delete_old=True)
finalize()
vtk_visualiser = True
if vtk_visualiser:
from anuga.visualiser import RealtimeVisualiser
vis = RealtimeVisualiser(domain)
vis.render_quantity_height("height",dynamic=True)
#vis.render_quantity_height("stage", zScale =1.0, dynamic=True)
vis.colour_height_quantity('stage', (0.0, 0.0, 1.0))
vis.start()
#===============================================================================
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
i = 0
for t in domain.evolve(yieldstep = 0.01, finaltime = 0.25):
#print domain.timestepping_statistics(track_speeds=True)
print domain.timestepping_statistics()
if vtk_visualiser:
vis.update()
fileName = 'stage_%03d' % i + '.vtk'
i = i+1
vis.store_height_quantity('height',fileName)
#test against know data
if vtk_visualiser: vis.evolveFinished()
#Bd = anuga.Dirichlet_boundary([1,0.,0.]) # Constant boundary values
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Br, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file = open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(), parameter_file, indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
import time
t0 = time.time()
for t in domain.evolve(yieldstep=0.1, finaltime=5.0):
#print(domain.timestepping_statistics(track_speeds=True))
if myid == 0 and verbose: print(domain.timestepping_statistics())
#vis.update()
if myid == 0 and verbose: print('That took %s sec' % str(time.time() - t0))
domain.sww_merge(delete_old=True)
finalize()
def concept_ungenerateII(self):
from anuga import Domain, Reflective_boundary, Dirichlet_boundary
x = 0
y = 0
mesh_geo = geo_reference = Geo_reference(56, x, y)
# These are the absolute values
polygon_absolute = [[0, 0], [100, 0], [100, 100], [0, 100]]
x_p = -10
y_p = -40
geo_ref_poly = Geo_reference(56, x_p, y_p)
polygon = geo_ref_poly.change_points_geo_ref(polygon_absolute)
boundary_tags = {'wall': [0, 1, 3], 'wave': [2]}
inner1_polygon_absolute = [[10, 10], [20, 10], [20, 20], [10, 20]]
inner1_polygon = geo_ref_poly.\
change_points_geo_ref(inner1_polygon_absolute)
inner2_polygon_absolute = [[30, 30], [40, 30], [40, 40], [30, 40]]
inner2_polygon = geo_ref_poly.\
change_points_geo_ref(inner2_polygon_absolute)
max_area = 1
interior_regions = [(inner1_polygon, 5), (inner2_polygon, 10)]
m = create_mesh_from_regions(polygon,
boundary_tags,
max_area,
interior_regions=interior_regions,
poly_geo_reference=geo_ref_poly,
mesh_geo_reference=mesh_geo)
m.export_mesh_file('a_test_mesh_iknterface.tsh')
fileName = tempfile.mktemp('.txt')
file = open(fileName, 'w')
file.write(' 1 ?? ??\n\
90.0 90.0\n\
81.0 90.0\n\
81.0 81.0\n\
90.0 81.0\n\
90.0 90.0\n\
END\n\
2 ?? ??\n\
10.0 80.0\n\
10.0 90.0\n\
20.0 90.0\n\
10.0 80.0\n\
END\n\
END\n')
file.close()
m.import_ungenerate_file(fileName) #, tag='wall')
os.remove(fileName)
m.generate_mesh(maximum_triangle_area=max_area, verbose=False)
mesh_filename = 'bento_b.tsh'
m.export_mesh_file(mesh_filename)
domain = Domain(mesh_filename, use_cache=False)
Br = Reflective_boundary(domain)
Bd = Dirichlet_boundary([3, 0, 0])
domain.set_boundary({'wall': Br, 'wave': Bd})
yieldstep = 0.1
finaltime = 10
for t in domain.evolve(yieldstep, finaltime):
domain.write_time()
def test_runup_sinusoid(self):
""" Run a version of the validation test runup_sinusoid
to ensure limiting solution has small velocity
"""
points, vertices, boundary = anuga.rectangular_cross(20,20, len1=1., len2=1.)
domain=Domain(points,vertices,boundary) # Create Domain
domain.set_flow_algorithm('DE0')
domain.set_name('runup_sinusoid_v2') # Output to file runup.sww
domain.set_datadir('.') # Use current folder
domain.set_quantities_to_be_stored({'stage': 2, 'xmomentum': 2, 'ymomentum': 2, 'elevation': 1})
#domain.set_store_vertices_uniquely(True)
#------------------
# Define topography
#------------------
scale_me=1.0
def topography(x,y):
return (-x/2.0 +0.05*num.sin((x+y)*50.0))*scale_me
def stagefun(x,y):
stge=-0.2*scale_me #+0.01*(x>0.9)
return stge
domain.set_quantity('elevation',topography) # Use function for elevation
domain.get_quantity('elevation').smooth_vertex_values()
domain.set_quantity('friction',0.03) # Constant friction
domain.set_quantity('stage', stagefun) # Constant negative initial stage
domain.get_quantity('stage').smooth_vertex_values()
#--------------------------
# Setup boundary conditions
#--------------------------
Br=anuga.Reflective_boundary(domain) # Solid reflective wall
Bd=anuga.Dirichlet_boundary([-0.1*scale_me,0.,0.]) # Constant boundary values -- not used in this example
#----------------------------------------------
# Associate boundary tags with boundary objects
#----------------------------------------------
domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom':Br})
#------------------------------
#Evolve the system through time
#------------------------------
for t in domain.evolve(yieldstep=7.0,finaltime=7.0):
#print domain.timestepping_statistics()
xx = domain.quantities['xmomentum'].centroid_values
yy = domain.quantities['ymomentum'].centroid_values
dd = domain.quantities['stage'].centroid_values - domain.quantities['elevation'].centroid_values
#dd_raw=1.0*dd
dd = (dd)*(dd>1.0e-03)+1.0e-03
vv = ( (xx/dd)**2 + (yy/dd)**2)**0.5
vv = vv*(dd>1.0e-03)
#print 'Peak velocity is: ', vv.max(), vv.argmax()
#print 'Volume is', sum(dd_raw*domain.areas)
#print vv.max()
assert num.all(vv<1.01e-01)
def parallel_time_varying_file_boundary_sts(self):
""" parallel_test_time_varying_file_boundary_sts_sequential(self):
Read correct points from ordering file and apply sts to boundary.
The boundary is time varying. Compares sequential result with
distributed result found using anuga_parallel
"""
#------------------------------------------------------------
# Define test variables
#------------------------------------------------------------
lat_long_points=[[6.01,97.0],[6.02,97.0],[6.05,96.9],[6.0,97.0]]
bounding_polygon=[[6.0,97.0],[6.01,97.0],[6.02,97.0],
[6.02,97.02],[6.00,97.02]]
tide = 3.0
time_step_count = 65
time_step = 2
n=len(lat_long_points)
first_tstep=num.ones(n,num.int)
last_tstep=(time_step_count)*num.ones(n,num.int)
finaltime=num.float(time_step*(time_step_count-1))
yieldstep=num.float(time_step)
gauge_depth=20*num.ones(n,num.float)
ha=2*num.ones((n,time_step_count),num.float)
ua=10*num.ones((n,time_step_count),num.float)
va=-10*num.ones((n,time_step_count),num.float)
times=num.arange(0, time_step_count*time_step, time_step)
for i in range(n):
#ha[i]+=num.sin(times)
ha[i]+=times/finaltime
#------------------------------------------------------------
# Write mux data to file then convert to sts format
#------------------------------------------------------------
sts_file="test"
if myid==0:
base_name, files = self.write_mux2(lat_long_points,
time_step_count,
time_step,
first_tstep,
last_tstep,
depth=gauge_depth,
ha=ha,
ua=ua,
va=va)
# base name will not exist, but 3 other files are created
# Write order file
file_handle, order_base_name = tempfile.mkstemp("")
os.close(file_handle)
os.remove(order_base_name)
d=","
order_file=order_base_name+'order.txt'
fid=open(order_file,'w')
# Write Header
header='index, longitude, latitude\n'
fid.write(header)
indices=[3,0,1]
for i in indices:
line=str(i)+d+str(lat_long_points[i][1])+d+\
str(lat_long_points[i][0])+"\n"
fid.write(line)
fid.close()
urs2sts(base_name,
basename_out=sts_file,
ordering_filename=order_file,
mean_stage=tide,
verbose=verbose)
self.delete_mux(files)
assert(os.access(sts_file+'.sts', os.F_OK))
os.remove(order_file)
barrier()
#------------------------------------------------------------
# Define boundary_polygon on each processor. This polygon defines the
# urs boundary and lies on a portion of the bounding_polygon
#------------------------------------------------------------
boundary_polygon = create_sts_boundary(sts_file)
# Append the remaining part of the boundary polygon to be defined by
# the user
bounding_polygon_utm=[]
for point in bounding_polygon:
zone,easting,northing=redfearn(point[0],point[1])
bounding_polygon_utm.append([easting,northing])
boundary_polygon.append(bounding_polygon_utm[3])
boundary_polygon.append(bounding_polygon_utm[4])
assert num.allclose(bounding_polygon_utm,boundary_polygon)
extent_res=10000
meshname = 'urs_test_mesh' + '.tsh'
interior_regions=None
boundary_tags={'ocean': [0,1], 'otherocean': [2,3,4]}
#------------------------------------------------------------
# Create mesh on the master processor and store in file. This file
# is read in by each slave processor when needed
#------------------------------------------------------------
if myid==0:
create_mesh_from_regions(boundary_polygon,
boundary_tags=boundary_tags,
maximum_triangle_area=extent_res,
filename=meshname,
interior_regions=interior_regions,
verbose=verbose)
# barrier()
domain_fbound = Domain(meshname)
domain_fbound.set_quantities_to_be_stored(None)
domain_fbound.set_quantity('stage', tide)
# print domain_fbound.mesh.get_boundary_polygon()
else:
domain_fbound=None
barrier()
if ( verbose and myid == 0 ):
print 'DISTRIBUTING PARALLEL DOMAIN'
domain_fbound = distribute(domain_fbound)
#--------------------------------------------------------------------
# Find which sub_domain in which the interpolation points are located
#
# Sometimes the interpolation points sit exactly
# between two centroids, so in the parallel run we
# reset the interpolation points to the centroids
# found in the sequential run
#--------------------------------------------------------------------
interpolation_points = [[279000,664000], [280250,664130],
[279280,665400], [280500,665000]]
interpolation_points=num.array(interpolation_points)
#if myid==0:
# import pylab as P
# boundary_polygon=num.array(boundary_polygon)
# P.plot(boundary_polygon[:,0],boundary_polygon[:,1])
# P.plot(interpolation_points[:,0],interpolation_points[:,1],'ko')
# P.show()
fbound_gauge_values = []
fbound_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
fbound_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_fbound.get_triangle_containing_point(point)
if domain_fbound.tri_full_flag[k] == 1:
fbound_proc_tri_ids.append(k)
else:
fbound_proc_tri_ids.append(-1)
except:
fbound_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' %(myid, fbound_proc_tri_ids)
#------------------------------------------------------------
# Set boundary conditions
#------------------------------------------------------------
Bf = File_boundary(sts_file+'.sts',
domain_fbound,
boundary_polygon=boundary_polygon)
Br = Reflective_boundary(domain_fbound)
domain_fbound.set_boundary({'ocean': Bf,'otherocean': Br})
#------------------------------------------------------------
# Evolve the domain on each processor
#------------------------------------------------------------
for i, t in enumerate(domain_fbound.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
stage = domain_fbound.get_quantity('stage')
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i].append(stage.centroid_values[fbound_proc_tri_ids[i]])
#------------------------------------------------------------
# Create domain to be run sequntially on each processor
#------------------------------------------------------------
domain_drchlt = Domain(meshname)
domain_drchlt.set_quantities_to_be_stored(None)
domain_drchlt.set_starttime(time_step)
domain_drchlt.set_quantity('stage', tide)
Br = Reflective_boundary(domain_drchlt)
#Bd = Dirichlet_boundary([2.0+tide,220+10*tide,-220-10*tide])
Bd = Time_boundary(domain=domain_drchlt, function=lambda t: [2.0+t/finaltime+tide,220.+10.*tide+10.*t/finaltime,-220.-10.*tide-10.*t/finaltime])
#Bd = Time_boundary(domain=domain_drchlt,function=lambda t: [2.0+num.sin(t)+tide,10.*(2+20.+num.sin(t)+tide),-10.*(2+20.+num.sin(t)+tide)])
domain_drchlt.set_boundary({'ocean': Bd,'otherocean': Br})
drchlt_gauge_values = []
drchlt_proc_tri_ids = []
for i, point in enumerate(interpolation_points):
drchlt_gauge_values.append([]) # Empty list for timeseries
try:
k = domain_drchlt.get_triangle_containing_point(point)
if domain_drchlt.tri_full_flag[k] == 1:
drchlt_proc_tri_ids.append(k)
else:
drchlt_proc_tri_ids.append(-1)
except:
drchlt_proc_tri_ids.append(-2)
if verbose: print 'P%d has points = %s' %(myid, drchlt_proc_tri_ids)
#------------------------------------------------------------
# Evolve entire domain on each processor
#------------------------------------------------------------
for i, t in enumerate(domain_drchlt.evolve(yieldstep=yieldstep,
finaltime=finaltime,
skip_initial_step = False)):
stage = domain_drchlt.get_quantity('stage')
for i in range(4):
drchlt_gauge_values[i].append(stage.centroid_values[drchlt_proc_tri_ids[i]])
#------------------------------------------------------------
# Compare sequential values with parallel values
#------------------------------------------------------------
barrier()
success = True
for i in range(4):
if fbound_proc_tri_ids[i] > -1:
fbound_gauge_values[i]=num.array(fbound_gauge_values[i])
drchlt_gauge_values[i]=num.array(drchlt_gauge_values[i])
#print i,fbound_gauge_values[i][4]
#print i,drchlt_gauge_values[i][4]
success = success and num.allclose(fbound_gauge_values[i], drchlt_gauge_values[i])
assert success#, (fbound_gauge_values[i]-drchlt_gauge_values[i])
#assert_(success)
if not sys.platform == 'win32':
if myid==0: os.remove(sts_file+'.sts')
if myid==0: os.remove(meshname)
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file=open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(),parameter_file,indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep = 0.1, finaltime = 5.):
#print domain.timestepping_statistics(track_speeds=True)
if myid == 0: print domain.timestepping_statistics()
domain.sww_merge(delete_old=True)
finalize()
#
# Inflow boundary -- use discharge inflow, and reflective wall (so we can control the discharge)
line = [[0., 0.], [0., W]]
Qin = 1.0 * W
Inlet_operator(domain, line, Qin)
# Associate boundary tags with boundary objects
domain.set_boundary({'left': Br, 'right': Bd_out, 'top': Br, 'bottom': Br})
#------------------------------------------------------------------------------
# Produce a documentation of parameters
#------------------------------------------------------------------------------
if myid == 0:
parameter_file = open('parameters.tex', 'w')
parameter_file.write('\\begin{verbatim}\n')
from pprint import pprint
pprint(domain.get_algorithm_parameters(), parameter_file, indent=4)
parameter_file.write('\\end{verbatim}\n')
parameter_file.close()
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=2.0, finaltime=200.):
#print(domain.timestepping_statistics(track_speeds=True))
if myid == 0 and verbose: print(domain.timestepping_statistics())
domain.sww_merge(delete_old=True)
finalize()
from anuga.operators.vegetation_operator import Vegetation_operator
# create operator
op1 = Vegetation_operator(domain)
# op1.set_inflow_concentration(0.02)
alpha = 0.4
Quantity(domain, name='veg_diameter', register=True)
domain.set_quantity('veg_diameter', 0.00064)
Quantity(domain, name='veg_spacing', register=True)
domain.set_quantity('veg_spacing', 0.15)
#------------------------------------------------------------------------------
# Evolve system through time
#------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=0.5, finaltime=30.):
domain.print_timestepping_statistics()
#domain.print_operator_timestepping_statistics()
Bi = Dirichlet_boundary([0.5, 0, 0]) # Inflow
Br = Reflective_boundary(domain) # Solid reflective wall
Bo = Dirichlet_boundary([-5, 0, 0]) # Outflow
domain.set_boundary({'left': Bi, 'right': Bo, 'top': Br, 'bottom': Br})
#-------------------------------------------------------------------------------
# Setup erosion operator in the middle of dam
#-------------------------------------------------------------------------------
polygon1 = [ [12., 0.0], [13., 0.0], [13., 5.0], [12., 5.0] ]
op1 = My_polygon_erosion_operator(domain, threshold=0.0, base=-0.1, polygon=polygon1)
#-------------------------------------------------------------------------------
# Evolve system through time
#-------------------------------------------------------------------------------
for t in domain.evolve(yieldstep=0.2, finaltime=60.0):
domain.print_timestepping_statistics()
domain.print_operator_timestepping_statistics()
