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_prediction_cloud_configuration():
output_directory = OUTPUT_DIRECTORY / "test_prediction_cloud_configuration"
reference_directory = REFERENCE_DIRECTORY / "test_prediction_cloud_configuration"
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
configuration = PredictionConfiguration(
launch_site=(-78.4987, 40.0157),
launch_time="2022-03-05 10:36:00",
ascent_rate=6.5,
burst_altitude=25000,
descent_rate=9,
)
perturbations = [
PredictionConfiguration(
launch_site=(-78.4987, 40.0157),
launch_time="2022-03-05 10:36:00",
ascent_rate=6.5,
burst_altitude=burst_altitude,
descent_rate=9,
) for burst_altitude in [20000, 22000, 24000, 26000, 28000, 30000]
]
cloud_configuration = PredictionCloudConfiguration(
default=configuration, perturbations=perturbations)
cloud_configuration.to_file(output_directory / "prediction_cloud.yaml")
check_reference_directory(output_directory, reference_directory)
def test_slurm_driver(shinnecock_mesh_directory):
output_directory = OUTPUT_DIRECTORY / 'test_slurm_driver'
reference_directory = REFERENCE_DIRECTORY / 'test_slurm_driver'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
mesh = AdcircMesh.open(shinnecock_mesh_directory / 'fort.14', crs=4326)
slurm = SlurmConfig(
account='account',
ntasks=1000,
run_name='adcircpy/tests/test_configuration.py',
partition='partition',
walltime=timedelta(hours=8),
mail_type='all',
mail_user='******',
log_filename='test_configuration.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,
)
DriverFile(driver).write(output_directory / 'slurm.job', overwrite=True)
check_reference_directory(output_directory, reference_directory)
def test_vortex_types():
output_directory = OUTPUT_DIRECTORY / 'test_vortex_types'
reference_directory = REFERENCE_DIRECTORY / 'test_vortex_types'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
file_decks = {
'a': {
'start_date': parse_date('2018-09-11 06:00'),
'end_date': None,
'record_types': ['OFCL', 'HWRF', 'HMON', 'CARQ'],
},
'b': {
'start_date': parse_date('2018-09-11 06:00'),
'end_date': parse_date('2018-09-18 06:00'),
'record_types': ['BEST'],
},
}
for file_deck, values in file_decks.items():
for record_type in values['record_types']:
cyclone = VortexForcing(
'al062018',
start_date=values['start_date'],
end_date=values['end_date'],
file_deck=file_deck,
record_type=record_type,
)
cyclone.write(
output_directory / f'{file_deck}-deck_{record_type}.txt', overwrite=True
)
check_reference_directory(output_directory, reference_directory)
def test_tidal_run(shinnecock_mesh_directory):
output_directory = OUTPUT_DIRECTORY / 'test_tidal_run'
reference_directory = REFERENCE_DIRECTORY / 'test_tidal_run'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
mesh = AdcircMesh.open(shinnecock_mesh_directory / 'fort.14', crs=4326)
tidal_forcing = Tides()
tidal_forcing.use_all()
mesh.add_forcing(tidal_forcing)
now = datetime.utcnow()
driver = AdcircRun(
mesh,
start_date=now,
end_date=now + timedelta(days=0.5),
spinup_time=timedelta(days=0.5),
)
driver.timestep = 10.0
if shutil.which('padcirc') is not None:
driver.run(output_directory, nproc=2, overwrite=True)
else:
driver.write(output_directory, nproc=2, overwrite=True)
check_reference_directory(
output_directory,
reference_directory,
skip_lines={'fort.15': [0, *range(32, 47, 2), *range(49, 64, 2), -2]},
)
def test_tidal_run_cli(shinnecock_mesh_directory, mocker):
output_directory = OUTPUT_DIRECTORY / 'test_tidal_run_cli'
reference_directory = REFERENCE_DIRECTORY / 'test_tidal_run_cli'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
cmd = [
'tidal_run',
f'{shinnecock_mesh_directory / "fort.14"}',
f"{datetime.strftime(datetime.utcnow(), '%Y-%m-%dT%H:%M:%S')}",
'0.5',
'--spinup-days=0.5',
'--crs=EPSG:4326',
f'--output-directory={output_directory}',
'--constituents=all',
'--overwrite',
'--timestep=10.',
'--nproc=2',
]
if shutil.which('padcirc') is None:
if shutil.which('adcirc') is not None:
cmd.append('--nproc=1')
else:
cmd.append('--skip-run')
mocker.patch('sys.argv', cmd)
tidal_run.main()
check_reference_directory(
output_directory,
reference_directory,
skip_lines={'fort.15': [0, *range(32, 47, 2), *range(49, 64, 2), -2]},
)
def test_write_txt(packet_track):
reference_directory = REFERENCE_DIRECTORY / "test_write_txt"
output_directory = OUTPUT_DIRECTORY / "test_write_txt"
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
write_packet_tracks([packet_track], output_directory / "tracks.txt")
check_reference_directory(output_directory, reference_directory)
def test_credentials_configuration():
output_directory = OUTPUT_DIRECTORY / "test_credentials_configuration"
reference_directory = REFERENCE_DIRECTORY / "test_credentials_configuration"
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
configuration = CredentialsYAML()
configuration.to_file(output_directory / "credentials.yaml")
check_reference_directory(output_directory, reference_directory)
def test_example_3():
reference_directory = REFERENCE_DIRECTORY / 'example_3'
output_directory = OUTPUT_DIRECTORY / 'example_3'
if output_directory.exists():
shutil.rmtree(output_directory)
output_directory.mkdir(exist_ok=True, parents=True)
exec(open(EXAMPLES_DIRECTORY / 'example_3.py').read())
check_reference_directory(output_directory,
reference_directory,
skip_lines={'fort.15': [0, -2]})
def test_recompute_velocity():
output_directory = OUTPUT_DIRECTORY / 'test_recompute_velocity'
reference_directory = REFERENCE_DIRECTORY / 'test_recompute_velocity'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
best_track = BestTrackForcing('irma2017', nws=8)
best_track.dataframe['latitude'][5] += 0.1
best_track.dataframe['longitude'][5] -= 0.1
best_track.write(output_directory / 'irma2017_fort.22', overwrite=True)
check_reference_directory(output_directory, reference_directory)
def test_configuration_from_file():
input_directory = INPUT_DIRECTORY / "test_configuration_from_file"
output_directory = OUTPUT_DIRECTORY / "test_configuration_from_file"
reference_directory = REFERENCE_DIRECTORY / "test_configuration_from_file"
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
configuration = RunConfiguration.from_file(input_directory /
"configuration.yaml")
configuration.to_file(output_directory / "configuration.yaml",
overwrite=True)
check_reference_directory(output_directory, reference_directory)
def test_configuration_files():
output_directory = OUTPUT_DIRECTORY / 'test_configuration_files'
reference_directory = REFERENCE_DIRECTORY / 'test_configuration_files'
start_time = datetime(2020, 6, 1)
duration = timedelta(days=1)
interval = timedelta(hours=1)
atmospheric_mesh = AtmosphericForcingEntry(ATMOSPHERIC_MESH_FILENAME)
wave_mesh = WaveWatch3ForcingEntry(WAVE_MESH_FILENAME, Verbosity='low')
ocean_model = ADCIRCEntry(11)
hydrological_model = NationalWaterModelEntry(769, Verbosity=VerbosityOption.MAX)
nems = ModelingSystem(
start_time,
start_time + duration,
interval,
atm=atmospheric_mesh,
wav=wave_mesh,
ocn=ocean_model,
hyd=hydrological_model,
Verbosity='off',
)
nems.connect('ATM', 'OCN')
nems.connect('WAV', 'OCN')
nems.connect('ATM', 'HYD')
nems.connect('WAV', 'HYD')
nems.connect('OCN', 'HYD')
sequence = [
'ATM -> OCN',
'WAV -> OCN',
'ATM -> HYD',
'WAV -> HYD',
'OCN -> HYD',
'ATM',
'WAV',
'OCN',
'HYD',
]
nems.sequence = sequence
nems.write(output_directory, overwrite=True, include_version=True)
assert nems.processors == 782
check_reference_directory(output_directory, reference_directory, skip_lines={'.*': [0]})
def test_prediction_configuration():
output_directory = OUTPUT_DIRECTORY / "test_prediction_configuration"
reference_directory = REFERENCE_DIRECTORY / "test_prediction_configuration"
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
configuration = PredictionConfiguration(
launch_site=(-78.4987, 40.0157),
launch_time="2022-03-05 10:36:00",
ascent_rate=6.5,
burst_altitude=25000,
descent_rate=9,
)
configuration.to_file(output_directory / "prediction.yaml")
check_reference_directory(output_directory, reference_directory)
def test_from_fort22():
input_directory = INPUT_DIRECTORY / 'test_from_fort22'
output_directory = OUTPUT_DIRECTORY / 'test_from_fort22'
reference_directory = REFERENCE_DIRECTORY / 'test_from_fort22'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
best_track = BestTrackForcing.from_fort22(
fort22=input_directory / 'irma2017_fort.22', nws=20,
)
assert best_track.storm_id == 'AL112017'
assert best_track.name == 'IRMA'
best_track.write(output_directory / 'irma2017_fort.22', overwrite=True)
check_reference_directory(output_directory, reference_directory)
def test_run_configuration():
output_directory = OUTPUT_DIRECTORY / "test_run_configuration"
reference_directory = REFERENCE_DIRECTORY / "test_run_configuration"
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
configuration = TestConfiguration(
test1=1,
test2="a",
test3=[True, False, True],
test4={
"a": 2,
"b": "test value",
"test5": "2"
},
)
configuration.to_file(output_directory / "test_run_configuration.yaml")
check_reference_directory(output_directory, reference_directory)
def test_from_atcf(mocker):
input_directory = INPUT_DIRECTORY / 'test_from_atcf'
output_directory = OUTPUT_DIRECTORY / 'test_from_atcf'
reference_directory = REFERENCE_DIRECTORY / 'test_from_atcf'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
best_track = BestTrackForcing.from_atcf_file(
atcf=input_directory / 'florence2018_atcf.trk', nws=8,
)
assert best_track.storm_id is None
assert best_track.name == 'WRT00001'
best_track.write(output_directory / 'florence2018_fort.22', overwrite=True)
check_reference_directory(output_directory, reference_directory)
mocker.patch('matplotlib.pyplot.show')
best_track.plot_track(show=True, coastline=False)
def test_Stations():
reference_directory = REFERENCE_DIRECTORY / 'test_Stations'
output_directory = OUTPUT_DIRECTORY / 'test_Stations'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
stations_1 = Stations.within_wind_swath(track=VortexTrack('florence2018'))
stations_2 = Stations.within_wind_swath(track=VortexTrack('florence2018'),
station_types=['ELEVATION'])
stations_3 = Stations.within_wind_swath(
track=VortexTrack('florence2018'),
station_types={
'ELEVATION': [8658120, 8670870, 8652587],
'VELOCITY': [8658120]
},
)
stations_1.write(output_directory / 'stations_1.fort.15', overwrite=True)
stations_2.write(output_directory / 'stations_2.fort.15', overwrite=True)
stations_3.write(output_directory / 'stations_3.fort.15', overwrite=True)
check_reference_directory(output_directory, reference_directory)
def test_no_internet():
input_directory = INPUT_DIRECTORY / 'test_no_internet'
output_directory = OUTPUT_DIRECTORY / 'test_no_internet'
reference_directory = REFERENCE_DIRECTORY / 'test_no_internet'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
with pytest.raises(pytest_socket.SocketBlockedError):
VortexForcing(storm='al062018', start_date='20180911', end_date=None)
vortex_1 = VortexForcing.from_fort22(input_directory / 'fort.22')
vortex_1.write(output_directory / 'vortex_1.22', overwrite=True)
vortex_2 = VortexForcing.from_fort22(vortex_1.filename)
vortex_2.write(output_directory / 'vortex_2.22', overwrite=True)
vortex_3 = copy(vortex_1)
vortex_3.write(output_directory / 'vortex_3.22', overwrite=True)
assert vortex_1 == vortex_2
assert vortex_1 == vortex_3
check_reference_directory(output_directory, reference_directory)
def test_best_track_run(shinnecock_mesh_directory, mocker):
input_directory = INPUT_DIRECTORY / 'test_best_track_run'
output_directory = OUTPUT_DIRECTORY / 'test_best_track_run'
reference_directory = REFERENCE_DIRECTORY / 'test_best_track_run'
if not output_directory.exists():
output_directory.mkdir(parents=True, exist_ok=True)
cmd = [
'best_track_run',
f'{shinnecock_mesh_directory / "fort.14"}',
'Sandy2012',
'--spinup-days=0.5',
'--crs=EPSG:4326',
f'--output-directory={str(output_directory)}',
'--constituents=all',
'--overwrite',
'--timestep=10.',
'--tau0-gen',
f'--stations-file={input_directory / "stations.txt"}',
'--elev-stat=6.',
'--run-days=0.5',
'--nproc=2',
]
if shutil.which('padcirc') is None:
if shutil.which('adcirc') is not None:
cmd.append('--nproc=1')
else:
cmd.append('--skip-run')
mocker.patch('sys.argv', cmd)
best_track_run.main()
check_reference_directory(output_directory,
reference_directory,
skip_lines={'fort.15': [0, -1]})
