def test_triangles_only(nodes, elements):
mesh = AdcircMesh(
nodes,
{id: geom
for geom in elements.values() if len(geom) == 3},
)
assert isinstance(mesh, AdcircMesh)
def test_sms2dm(self):
self.boundaries[None][0].update({'properties': {}})
msh = AdcircMesh(
self.nodes,
self.elements,
crs="EPSG:3395",
boundaries=self.boundaries)
self.assertIsInstance(msh.sms2dm, str)
def test_quads_only(self):
self.assertIsInstance(
AdcircMesh(
self.nodes,
{id: geom for geom in self.elements.values() if len(geom) == 4}
),
AdcircMesh
)
def main():
# fetch shinnecock inlet test data
if not FORT14.is_file():
url = "https://www.dropbox.com/s/1wk91r67cacf132/"
url += "NetCDF_shinnecock_inlet.tar.bz2?dl=1"
g = urllib.request.urlopen(url)
tmpfile = tempfile.NamedTemporaryFile()
with open(tmpfile.name, 'b+w') as f:
f.write(g.read())
with tarfile.open(tmpfile.name, "r:bz2") as tar:
tar.extractall(PARENT / "data/NetCDF_Shinnecock_Inlet/")
# open mesh file
mesh = AdcircMesh.open(FORT14, crs=4326)
# init tidal forcing and setup requests
tidal_forcing = Tides()
tidal_forcing.use_constituent('M2')
tidal_forcing.use_constituent('N2')
tidal_forcing.use_constituent('S2')
tidal_forcing.use_constituent('K1')
tidal_forcing.use_constituent('O1')
mesh.add_forcing(tidal_forcing)
# set simulation dates
start_date = datetime(2015, 12, 14)
end_date = start_date + timedelta(days=5)
# instantiate AdcircRun object.
driver = AdcircRun(mesh, start_date, end_date)
# request outputs
driver.set_elevation_surface_output(sampling_rate=timedelta(minutes=30))
driver.set_velocity_surface_output(sampling_rate=timedelta(minutes=30))
# override the AdcircPy defaults so that the fort.15
# matches the original Shinnecock test case options
driver.timestep = 6.
driver.DRAMP = 2.
driver.TOUTGE = 3.8
driver.TOUTGV = 3.8
driver.smagorinsky = False
driver.horizontal_mixing_coefficient = 5.
driver.gwce_solution_scheme = 'semi-implicit-legacy'
# run parallel ADCIRC if binary is installed
if shutil.which('padcirc') is not None:
driver.run(PARENT / "outputs/example_1", overwrite=True)
# run serial ADCIRC if binary is installed
elif shutil.which('adcirc') is not None:
driver.run(PARENT / "outputs/example_1", overwrite=True, nproc=1)
# binaries are not installed, write to disk and exit
else:
msg = 'ADCIRC binaries were not found in PATH. ADCIRC will not run. '
msg += "Writing files to disk..."
warnings.warn(msg)
driver.write(PARENT / "outputs/example_1", overwrite=True)
def test_add_attribute(self):
attributes = {
'test_attribute_1': {'test_1': 'a', 'test_2': 2},
'test_attribute_2': {'test_1': 'b', 'test_2': 3}
}
mesh = AdcircMesh(self.nodes, self.elements)
self.assertRaises(AttributeError, mesh.get_attribute,
list(attributes)[0])
for name, properties in attributes.items():
mesh.add_attribute(name, **properties)
self.assertEquals(
{'values': None, 'properties': None, **properties},
mesh.get_attribute(name))
self.assertRaises(AttributeError, mesh.add_attribute,
list(attributes)[0])
def test_open(self):
tmpfile = tempfile.NamedTemporaryFile()
with open(tmpfile.name, 'w') as f:
f.write(f'\n{len(self.elements):d} {len(self.nodes):d}\n')
for id, ((x, y), z) in self.nodes.items():
f.write(f'{id} {x} {y} {z}\n')
for id, geom in self.elements.items():
f.write(f'{id} {len(geom)} {" ".join(idx for idx in geom)}\n')
self.assertIsInstance(AdcircMesh.open(tmpfile.name), AdcircMesh)
def test_nan_boundaries_raises(self):
self.boundaries[None][0].update({'properties': {}})
self.nodes['1'] = ((0., 0.), numpy.nan)
msh = AdcircMesh(
self.nodes,
self.elements,
crs="EPSG:3395",
boundaries=self.boundaries)
self.assertRaises(Exception, msh.generate_boundaries)
def test_write_boundaries_raises(self):
tmpdir = tempfile.TemporaryDirectory()
shp = pathlib.Path(tmpdir.name).absolute()
msh = AdcircMesh(
self.nodes,
self.elements,
crs="EPSG:3395",
boundaries=self.boundaries)
msh._logger.debug('coverage')
self.assertRaises(IOError, msh.write_boundaries, shp)
def __init__(self, args: argparse.Namespace):
mesh = AdcircMesh.open(args.mesh, crs=args.crs)
fig = plt.figure()
ax = fig.add_subplot(111)
if args.no_topobathy is False:
mesh.make_plot(axes=ax, vmin=args.vmin, vmax=args.vmax)
if args.show_elements:
mesh.triplot(axes=ax)
if args.plot_boundaries:
mesh.boundaries.gdf.plot(ax=ax)
plt.show(block=True)
def run(self):
mesh = AdcircMesh.open(self.args.mesh, crs=self.args.crs)
ax = None
if not self.args.no_topobathy:
ax = mesh.make_plot(
vmin=self.args.vmin,
vmax=self.args.vmax,
)
if self.args.show_elements:
ax = mesh.triplot(axes=ax)
if self.args.plot_boundaries:
self.mesh.boundaries.gdf.plot(ax=self.ax)
def main():
args = parse_args()
tides = Tides(tidal_source=args.tidal_database)
tides.use_all()
tides.start_date = args.start_date
tides.end_date = tides.start_date + timedelta(days=args.run_days)
mesh = AdcircMesh.open(args.mesh, crs=args.mesh_crs)
mesh.add_forcing(tides)
fort15 = Fort15(mesh)
if args.output_file is not None:
open(args.output_file, 'w').write(fort15.get_tidal_forcing())
else:
print(fort15.get_tidal_forcing())
def test_open(fort14):
output_directory = OUTPUT_DIRECTORY / 'test_open'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
mesh_filename = output_directory / 'fort.14'
with open(mesh_filename, 'w') as temporary_file:
temporary_file.write(fort14)
mesh = AdcircMesh.open(mesh_filename)
assert isinstance(mesh, AdcircMesh)
def main():
if not FORT14.is_file():
url = 'https://www.dropbox.com/s/1wk91r67cacf132/NetCDF_shinnecock_inlet.tar.bz2?dl=1'
g = urllib.request.urlopen(url)
tmpfile = tempfile.NamedTemporaryFile()
with open(tmpfile.name, 'b+w') as f:
f.write(g.read())
with tarfile.open(tmpfile.name, "r:bz2") as tar:
tar.extractall(PARENT / "data/NetCDF_Shinnecock_Inlet/")
mesh = AdcircMesh.open(FORT14, crs=4326)
tidal_forcing = Tides()
tidal_forcing.use_all()
wind_forcing = AtmosphericMeshForcing(
filename='Wind_HWRF_SANDY_Nov2018_ExtendedSmoothT.nc',
nws=17,
interval_seconds=3600,
)
wave_forcing = WaveWatch3DataForcing(
filename='ww3.HWRF.NOV2018.2012_sxy.nc',
nrs=5,
interval_seconds=3600,
)
mesh.add_forcing(tidal_forcing)
mesh.add_forcing(wind_forcing)
mesh.add_forcing(wave_forcing)
slurm = SlurmConfig(
account='account',
ntasks=1000,
run_name='AdcircPy/examples/example_3.py',
partition='partition',
walltime=timedelta(hours=8),
mail_type='all',
mail_user='******',
log_filename='example_3.log',
modules=['intel/2020', 'impi/2020', 'netcdf/4.7.2-parallel'],
path_prefix='$HOME/adcirc/build')
driver = AdcircRun(
mesh=mesh,
start_date=datetime.now(),
end_date=timedelta(days=7),
spinup_time=timedelta(days=5),
server_config=slurm,
)
driver.write(PARENT / "outputs/example_4", overwrite=True)
def test_write(nodes, elements):
output_directory = OUTPUT_DIRECTORY / 'test_write'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
mesh = AdcircMesh(nodes, elements)
mesh.write(output_directory / 'test_AdcircMesh.gr3', overwrite=True)
mesh.write(output_directory / 'test_AdcircMesh.2dm',
format='2dm',
overwrite=True)
with pytest.raises(ValueError):
mesh.write(output_directory / 'test_AdcircMesh.txt',
format='txt',
overwrite=True)
def _mesh(self):
mesh = AdcircMesh.open(self.args.mesh, self.args.crs)
if self.args.generate_boundaries:
mesh.generate_boundaries(
threshold=self.args.boundaries_threshold,
land_ibtype=self.args.land_ibtype,
interior_ibtype=self.args.island_ibtype,
)
# set nodal attributes
if self.args.fort13 is not None:
mesh.import_nodal_attributes(
pathlib.Path(self.args.fort13).resolve())
if 'all' in self.args.coldstart_attributes:
for attr in mesh.get_nodal_attribute_names():
mesh.set_nodal_attribute_coldstart_state(attr, True)
else:
for attr in self.args.coldstart_attributes:
mesh.set_nodal_attribute_coldstart_state(attr, True)
if 'all' in self.args.hotstart_attributes:
for attr in mesh.get_nodal_attribute_names():
mesh.set_nodal_attribute_hotstart_state(attr, True)
else:
for attr in self.args.hotstart_attributes:
mesh.set_nodal_attribute_hotstart_state(attr, True)
if self.args.generate_tau0:
mesh.generate_tau0()
if self.args.generate_linear_mannings is True:
mesh.generate_linear_mannings_n()
elif self.args.generate_constant_mannings is not None:
mesh.generate_constant_mannings_n(
self.args.generate_constant_mannings)
if self.tidal_forcing is not None:
mesh.add_forcing(self.tidal_forcing)
if self.wave_forcing is not None:
mesh.add_forcing(self.wave_forcing)
if self.wind_forcing is not None:
mesh.add_forcing(self.wind_forcing)
return mesh
def test_write(self):
h = AdcircMesh(self.nodes, self.elements)
tmpdir = tempfile.TemporaryDirectory()
h.write(pathlib.Path(tmpdir.name) / 'test_AdcircMesh.gr3')
h.write(pathlib.Path(tmpdir.name) / 'test_AdcircMesh.2dm', fmt='2dm')
self.assertRaises(IOError, h.write,
pathlib.Path(tmpdir.name) / 'test_AdcircMesh.2dm',
fmt='2dm')
self.assertRaises(IOError, h.write,
pathlib.Path(tmpdir.name) / 'test_AdcircMesh.txt',
fmt='txt')
def test_import_stations(shinnecock_mesh_directory):
input_directory = INPUT_DIRECTORY / 'test_import_stations'
mesh = AdcircMesh.open(shinnecock_mesh_directory / 'fort.14', crs=4326)
spinup_time = timedelta(days=2)
start_date = datetime(2015, 12, 14) + spinup_time
end_date = start_date + timedelta(days=3)
driver_1 = AdcircRun(copy(mesh), start_date, end_date, spinup_time)
driver_1.import_stations(input_directory / 'stations_1.txt',
only_within=True)
driver_2 = AdcircRun(copy(mesh), start_date, end_date, spinup_time)
driver_2.import_stations(input_directory / 'stations_2.txt',
only_within=True)
driver_3 = AdcircRun(copy(mesh), start_date, end_date, spinup_time)
driver_3.import_stations(input_directory / 'stations_3.txt',
only_within=True)
driver_4 = AdcircRun(copy(mesh), start_date, end_date, spinup_time)
driver_4.import_stations(
input_directory / 'stations_3.txt',
station_types=['elevation', 'NSTAC', StationType.METEOROLOGICAL],
)
assert driver_1.elevation_stations == {'8512769': (-72.5772, 40.823)}
assert driver_1.velocity_stations == {}
assert driver_1.concentration_stations == {}
assert driver_1.meteorological_stations == {}
assert driver_2.elevation_stations == {'8512769': (-72.5772, 40.823)}
assert driver_2.velocity_stations == {'8512769': (-72.5772, 40.823)}
assert driver_2.concentration_stations == {}
assert driver_2.meteorological_stations == {}
assert driver_3.elevation_stations == {'8512769': (-72.5772, 40.823)}
assert driver_3.velocity_stations == {'8512769': (-72.5772, 40.823)}
assert driver_3.concentration_stations == {}
assert driver_3.meteorological_stations == {}
assert driver_4.elevation_stations == {'8512769': (-72.5772, 40.823)}
assert driver_4.velocity_stations == {}
assert driver_4.concentration_stations == {'8512769': (-72.5772, 40.823)}
assert driver_4.meteorological_stations == {}
def test_configuration(self):
output_directory = OUTPUT_DIRECTORY / 'test_configuration'
reference_directory = REFERENCE_DIRECTORY / 'test_configuration'
output_directory.mkdir(parents=True, exist_ok=True)
# open mesh file
mesh = AdcircMesh.open(FORT14_FILENAME, crs=4326)
# set simulation dates
spinup_time = timedelta(days=2)
start_date = datetime(2015, 12, 14) + spinup_time
end_date = start_date + timedelta(days=3)
wind_forcing = AtmosphericMeshForcing(
filename='Wind_HWRF_SANDY_Nov2018_ExtendedSmoothT.nc',
nws=17,
interval_seconds=3600,
)
wave_forcing = WaveWatch3DataForcing(
filename='ww3.HWRF.NOV2018.2012_sxy.nc',
nrs=5,
interval_seconds=3600,
)
mesh.add_forcing(wind_forcing)
mesh.add_forcing(wave_forcing)
# instantiate AdcircRun object.
driver = AdcircRun(
mesh,
start_date,
end_date,
spinup_time,
)
driver.write(output_directory, overwrite=True)
for reference_filename in reference_directory.iterdir():
generated_filename = output_directory / reference_filename.name
with open(generated_filename) as generated_file, \
open(reference_filename) as reference_file:
self.assertMultiLineEqual(
''.join(generated_file.readlines()[1:]),
''.join(reference_file.readlines()[1:]))
def main():
# fetch shinnecock inlet test data
if not FORT14.is_file():
url = "https://www.dropbox.com/s/1wk91r67cacf132/"
url += "NetCDF_shinnecock_inlet.tar.bz2?dl=1"
g = urllib.request.urlopen(url)
tmpfile = tempfile.NamedTemporaryFile()
with open(tmpfile.name, 'b+w') as f:
f.write(g.read())
with tarfile.open(tmpfile.name, "r:bz2") as tar:
tar.extractall(PARENT / "data/NetCDF_Shinnecock_Inlet/")
# open mesh file
mesh = AdcircMesh.open(FORT14, crs=4326)
# init tidal forcing and setup requests
tidal_forcing = Tides()
tidal_forcing.use_all()
mesh.add_forcing(tidal_forcing)
# Add wind forcing to model
wind_forcing = BestTrackForcing('Sandy2012')
mesh.add_forcing(wind_forcing)
# instantiate AdcircRun object.
slurm = SlurmConfig(
account='account',
ntasks=1000,
run_name='AdcircPy/examples/example_3.py',
partition='partition',
walltime=timedelta(hours=8),
mail_type='all',
mail_user='******',
log_filename='example_3.log',
modules=['intel/2020', 'impi/2020', 'netcdf/4.7.2-parallel'],
path_prefix='$HOME/adcirc/build')
driver = AdcircRun(mesh,
spinup_time=timedelta(days=15),
server_config=slurm)
# Write driver state to file.
driver.write(PARENT / "outputs/example_3", overwrite=True)
def test_configuration(shinnecock_mesh_directory):
output_directory = OUTPUT_DIRECTORY / 'test_configuration'
reference_directory = REFERENCE_DIRECTORY / 'test_configuration'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
mesh = AdcircMesh.open(shinnecock_mesh_directory / 'fort.14', crs=4326)
spinup_time = timedelta(days=2)
start_date = datetime(2015, 12, 14) + spinup_time
end_date = start_date + timedelta(days=3)
wind_forcing = AtmosphericMeshForcing(
filename='Wind_HWRF_SANDY_Nov2018_ExtendedSmoothT.nc',
nws=17,
interval_seconds=3600,
)
wave_forcing = WaveWatch3DataForcing(
filename='ww3.HWRF.NOV2018.2012_sxy.nc',
nrs=5,
interval_seconds=3600,
)
mesh.add_forcing(wind_forcing)
mesh.add_forcing(wave_forcing)
driver = AdcircRun(
mesh,
start_date,
end_date,
spinup_time,
)
driver.write(output_directory, overwrite=True, nproc=2)
check_reference_directory(
output_directory,
reference_directory,
skip_lines={'fort.15': [0]},
)
def test_configuration(self):
output_directory = OUTPUT_DIRECTORY / 'test_configuration'
reference_directory = REFERENCE_DIRECTORY / 'test_configuration'
output_directory.mkdir(parents=True, exist_ok=True)
# open mesh file
mesh = AdcircMesh.open(FORT14_FILENAME, crs=4326)
# let's generate the tau0 factor
mesh.generate_tau0()
# let's also add a mannings to the domain (constant for this example)
mesh.mannings_n_at_sea_floor = numpy.full(mesh.values.shape, 0.025)
# set simulation dates
spinup_time = timedelta(days=2)
start_date = datetime(2015, 12, 14) + spinup_time
end_date = start_date + timedelta(days=3)
wind_forcing = AtmosphericMeshForcing(17, 3600)
wave_forcing = WaveWatch3DataForcing(5, 3600)
mesh.add_forcing(wind_forcing)
mesh.add_forcing(wave_forcing)
# instantiate AdcircRun object.
driver = AdcircRun(
mesh,
start_date,
end_date,
spinup_time,
)
driver.write(output_directory, overwrite=True)
for reference_filename in reference_directory.iterdir():
generated_filename = output_directory / reference_filename.name
with open(generated_filename) as generated_file, \
open(reference_filename) as reference_file:
assert generated_file.readlines()[1:] == \
reference_file.readlines()[1:]
def test_hybrid(self):
self.assertIsInstance(AdcircMesh(self.nodes, self.elements),
AdcircMesh)
def test_make_plot_flat_domain(self, mock):
nodes = {id: (coord, 0.) for id, (coord, _) in self.nodes.items()}
h = AdcircMesh(nodes, self.elements, self.boundaries)
h.make_plot()
def test_triplot(self):
h = AdcircMesh(self.nodes, self.elements, self.boundaries)
h.triplot()
def test_add_existing_boundary_type_raises(self):
msh = AdcircMesh(self.nodes, self.elements)
self.assertRaises(Exception, msh.add_boundary_type, None)
def test_make_plot_flat_domain(nodes, elements, boundaries, mocker):
nodes = {id: (*coord[:2], 0.0) for id, coord in nodes.items()}
mesh = AdcircMesh(nodes, elements, boundaries=boundaries)
mocker.patch('matplotlib.pyplot.show')
mesh.make_plot()
def test_triplot(nodes, elements, boundaries, mocker):
mesh = AdcircMesh(nodes, elements, boundaries=boundaries)
mocker.patch('matplotlib.pyplot.show')
mesh.triplot()
def test_hybrid(nodes, elements):
mesh = AdcircMesh(nodes, elements)
assert isinstance(mesh, AdcircMesh)
from adcircpy.utilities import download_mesh
DATA_DIRECTORY = Path(__file__).parent.absolute() / 'data'
INPUT_DIRECTORY = DATA_DIRECTORY / 'input' / 'shinnecock'
OUTPUT_DIRECTORY = DATA_DIRECTORY / 'output' / 'example_1'
MESH_DIRECTORY = INPUT_DIRECTORY / 'shinnecock'
download_mesh(
url='https://www.dropbox.com/s/1wk91r67cacf132/NetCDF_shinnecock_inlet.tar.bz2?dl=1',
directory=MESH_DIRECTORY,
known_hash='99d764541983bfee60d4176af48ed803d427dea61243fa22d3f4003ebcec98f4',
)
# open mesh file
mesh = AdcircMesh.open(MESH_DIRECTORY / 'fort.14', crs=4326)
# initialize tidal forcing and constituents
tidal_forcing = Tides()
tidal_forcing.use_constituent('M2')
tidal_forcing.use_constituent('N2')
tidal_forcing.use_constituent('S2')
tidal_forcing.use_constituent('K1')
tidal_forcing.use_constituent('O1')
mesh.add_forcing(tidal_forcing)
# set simulation dates
duration = timedelta(days=5)
start_date = datetime(2015, 12, 14)
end_date = start_date + duration
def test_plot_boundaries(self):
h = AdcircMesh(self.nodes, self.elements, self.boundaries)
h.plot_boundaries()
