def test_floating_sphere_finite_depth():
"""Compare with Nemoh 2.0 for some cases of a heaving sphere at the free surface in finite depth."""
sphere = Sphere(radius=1.0, ntheta=3, nphi=12, clip_free_surface=True)
sphere.add_translation_dof(direction=(0, 0, 1), name="Heave")
# omega = 1, radiation
problem = RadiationProblem(body=sphere, omega=1.0, radiating_dof="Heave", sea_bottom=-10.0)
result = solver.solve(problem, keep_details=True)
assert np.isclose(result.added_masses["Heave"], 1740.6, atol=1e-3*sphere.volume*problem.rho)
assert np.isclose(result.radiation_dampings["Heave"], 380.46, atol=1e-3*sphere.volume*problem.rho)
kochin = compute_kochin(result, np.linspace(0, np.pi, 3))
assert np.allclose(kochin, np.roll(kochin, 1)) # The far field is the same in all directions.
assert np.isclose(kochin[0], -0.2267+3.49e-3j, rtol=1e-3)
# omega = 1, diffraction
problem = DiffractionProblem(body=sphere, omega=1.0, wave_direction=0.0, sea_bottom=-10.0)
result = solver.solve(problem)
assert np.isclose(result.forces["Heave"], 1749.4 * np.exp(-2.922j), rtol=1e-3)
# omega = 2, radiation
problem = RadiationProblem(body=sphere, omega=2.0, radiating_dof="Heave", sea_bottom=-10.0)
result = solver.solve(problem)
assert np.isclose(result.added_masses["Heave"], 1375.0, atol=1e-3*sphere.volume*problem.rho)
assert np.isclose(result.radiation_dampings["Heave"], 1418.0, atol=1e-3*sphere.volume*problem.rho)
# omega = 2, diffraction
problem = DiffractionProblem(body=sphere, omega=2.0, wave_direction=0.0, sea_bottom=-10.0)
result = solver.solve(problem)
assert np.isclose(result.forces["Heave"], 5872.8 * np.exp(-2.627j), rtol=1e-3)
def test_floating_sphere_finite_freq():
"""Compare with Nemoh 2.0 for some cases of a heaving sphere at the free surface in infinite depth."""
sphere = Sphere(radius=1.0, ntheta=3, nphi=12, clip_free_surface=True)
sphere.add_translation_dof(direction=(0, 0, 1), name="Heave")
# omega = 1, radiation
problem = RadiationProblem(body=sphere, omega=1.0, sea_bottom=-np.infty)
result = solver.solve(problem, keep_details=True)
assert np.isclose(result.added_masses["Heave"], 1819.6, atol=1e-3*sphere.volume*problem.rho)
assert np.isclose(result.radiation_dampings["Heave"], 379.39, atol=1e-3*sphere.volume*problem.rho)
# omega = 1, free surface
free_surface = FreeSurface(x_range=(-62.5, 62.5), nx=5, y_range=(-62.5, 62.5), ny=5)
eta = solver.get_free_surface_elevation(result, free_surface)
ref = np.array(
[[-0.4340802E-02-0.4742809E-03j, -0.7986111E-03+0.4840984E-02j, 0.2214827E-02+0.4700642E-02j, -0.7986111E-03+0.4840984E-02j, -0.4340803E-02-0.4742807E-03j],
[-0.7986111E-03+0.4840984E-02j, 0.5733187E-02-0.2179381E-02j, 0.9460892E-03-0.7079404E-02j, 0.5733186E-02-0.2179381E-02j, -0.7986110E-03+0.4840984E-02j],
[0.2214827E-02+0.4700643E-02j, 0.9460892E-03-0.7079403E-02j, -0.1381670E-01+0.6039315E-01j, 0.9460892E-03-0.7079405E-02j, 0.2214827E-02+0.4700643E-02j],
[-0.7986111E-03+0.4840984E-02j, 0.5733186E-02-0.2179381E-02j, 0.9460891E-03-0.7079404E-02j, 0.5733187E-02-0.2179380E-02j, -0.7986113E-03+0.4840984E-02j],
[-0.4340803E-02-0.4742807E-03j, -0.7986111E-03+0.4840984E-02j, 0.2214827E-02+0.4700643E-02j, -0.7986113E-03+0.4840983E-02j, -0.4340803E-02-0.4742809E-03j]]
)
assert np.allclose(eta.reshape((5, 5)), ref, rtol=1e-4)
# omega = 1, diffraction
problem = DiffractionProblem(body=sphere, omega=1.0, sea_bottom=-np.infty)
result = solver.solve(problem, keep_details=True)
assert np.isclose(result.forces["Heave"], 1834.9 * np.exp(-2.933j), rtol=1e-3)
# omega = 1, Kochin function of diffraction problem
kochin = compute_kochin(result, np.linspace(0, np.pi, 10))
ref_kochin = np.array([
0.20229*np.exp(-1.5872j), 0.20369*np.exp(-1.5871j),
0.20767*np.exp(-1.5868j), 0.21382*np.exp(-1.5863j),
0.22132*np.exp(-1.5857j), 0.22931*np.exp(-1.5852j),
0.23680*np.exp(-1.5847j), 0.24291*np.exp(-1.5843j),
0.24688*np.exp(-1.5841j), 0.24825*np.exp(-1.5840j),
])
assert np.allclose(kochin, ref_kochin, rtol=1e-3)
# omega = 2, radiation
problem = RadiationProblem(body=sphere, omega=2.0, sea_bottom=-np.infty)
result = solver.solve(problem)
assert np.isclose(result.added_masses["Heave"], 1369.3, atol=1e-3*sphere.volume*problem.rho)
assert np.isclose(result.radiation_dampings["Heave"], 1425.6, atol=1e-3*sphere.volume*problem.rho)
# omega = 2, diffraction
problem = DiffractionProblem(body=sphere, omega=2.0, sea_bottom=-np.infty)
result = solver.solve(problem)
assert np.isclose(result.forces["Heave"], 5846.6 * np.exp(-2.623j), rtol=1e-3)
def test_Froude_Krylov():
from capytaine.bem.airy_waves import froude_krylov_force
from capytaine.bodies.predefined.spheres import Sphere
from capytaine.bem.problems_and_results import DiffractionProblem
sphere = Sphere(radius=1.0, ntheta=3, nphi=12, clever=True, clip_free_surface=True)
sphere.add_translation_dof(direction=(0, 0, 1), name="Heave")
problem = DiffractionProblem(body=sphere, omega=1.0, sea_bottom=-np.infty)
assert np.isclose(froude_krylov_force(problem)['Heave'], 27596, rtol=1e-3)
problem = DiffractionProblem(body=sphere, omega=2.0, sea_bottom=-np.infty)
assert np.isclose(froude_krylov_force(problem)['Heave'], 22491, rtol=1e-3)
problem = DiffractionProblem(body=sphere, omega=1.0, sea_bottom=-10.0)
assert np.isclose(froude_krylov_force(problem)['Heave'], 27610, rtol=1e-3)
def test_alien_sphere():
"""Compare with Nemoh 2.0 for some cases of a heaving sphere at the free surface in infinite depth
for a non-usual gravity and density."""
sphere = Sphere(radius=1.0, ntheta=3, nphi=12, clip_free_surface=True)
sphere.add_translation_dof(direction=(0, 0, 1), name="Heave")
sphere.add_translation_dof(direction=(1, 0, 0), name="Surge")
# radiation
problem = RadiationProblem(body=sphere,
rho=450.0,
g=1.625,
omega=1.0,
radiating_dof="Heave")
result = solver.solve(problem)
assert np.isclose(result.added_masses["Heave"],
515,
atol=1e-3 * sphere.volume * problem.rho)
assert np.isclose(result.radiation_dampings["Heave"],
309,
atol=1e-3 * sphere.volume * problem.rho)
# diffraction
problem = DiffractionProblem(body=sphere,
rho=450.0,
g=1.625,
omega=1.0,
sea_bottom=-np.infty)
result = solver.solve(problem)
assert np.isclose(result.forces["Heave"],
548.5 * np.exp(-2.521j),
rtol=1e-2)
def test_wave_direction_radians_warning(caplog):
sphere = Sphere(radius=1.0, ntheta=20, nphi=40)
sphere.keep_immersed_part()
sphere.add_all_rigid_body_dofs()
with caplog.at_level(logging.WARNING):
DiffractionProblem(body=sphere, omega=1.0, wave_direction=180)
assert 'in radians and not in degrees' in caplog.text
def test_multibody():
"""Compare with Nemoh 2.0 for two bodies."""
sphere = Sphere(radius=1.0, ntheta=5, nphi=20)
sphere.translate_z(-2.0)
sphere.add_translation_dof(direction=(1, 0, 0), name="Surge")
sphere.add_translation_dof(direction=(0, 0, 1), name="Heave")
cylinder = HorizontalCylinder(length=5.0,
radius=1.0,
nx=10,
nr=1,
ntheta=10)
cylinder.translate([+1.5, 3.0, -3.0])
cylinder.add_translation_dof(direction=(1, 0, 0), name="Surge")
cylinder.add_translation_dof(direction=(0, 0, 1), name="Heave")
both = cylinder + sphere
total_volume = cylinder.volume + sphere.volume
# both.show()
problems = [
RadiationProblem(body=both, radiating_dof=dof, omega=1.0)
for dof in both.dofs
]
problems += [DiffractionProblem(body=both, wave_direction=0.0, omega=1.0)]
results = [solver.solve(problem) for problem in problems]
data = assemble_dataset(results)
data_from_nemoh_2 = np.array([
[
3961.86548, 50.0367661, -3.32347107, 6.36901855E-02, 172.704819,
19.2018471, -5.67303181, -2.98873377
],
[
-3.08301544, 5.72392941E-02, 14522.1689, 271.796814, 128.413834,
6.03351116, 427.167358, 64.1587067
],
[
161.125534, 17.8332844, 126.392113, 5.88006783, 2242.47412,
7.17850924, 1.29002571, 0.393169671
],
[
-5.02560759, -2.75930357, 419.927460, 63.3179016, 1.23501396,
0.416424811, 2341.57593, 15.8266096
],
])
dofs_names = list(both.dofs.keys())
assert np.allclose(data['added_mass'].sel(
omega=1.0, radiating_dof=dofs_names, influenced_dof=dofs_names).values,
data_from_nemoh_2[:, ::2],
atol=1e-3 * total_volume * problems[0].rho)
assert np.allclose(data['radiation_damping'].sel(
omega=1.0, radiating_dof=dofs_names, influenced_dof=dofs_names).values,
data_from_nemoh_2[:, 1::2],
atol=1e-3 * total_volume * problems[0].rho)
def problems_from_dataset(dataset: xr.Dataset,
bodies: Sequence[FloatingBody],
) -> List[LinearPotentialFlowProblem]:
"""Generate a list of problems from a test matrix.
Parameters
----------
dataset : xarray Dataset
Test matrix containing the problems parameters.
bodies : list of FloatingBody
The bodies on which the computations of the test matrix will be applied.
They should all have different names.
Returns
-------
list of LinearPotentialFlowProblem
"""
assert len(list(set(body.name for body in bodies))) == len(bodies), \
"All bodies should have different names."
dataset = _unsqueeze_dimensions(dataset)
omega_range = dataset['omega'].data if 'omega' in dataset else [_default_parameters['omega']]
water_depth_range = dataset['water_depth'].data if 'water_depth' in dataset else [_default_parameters['water_depth']]
rho_range = dataset['rho'].data if 'rho' in dataset else [_default_parameters['rho']]
wave_direction_range = dataset['wave_direction'].data if 'wave_direction' in dataset else None
radiating_dofs = dataset['radiating_dof'].data.astype(object) if 'radiating_dof' in dataset else None
# astype(object) is meant to convert Numpy internal string type numpy.str_ to Python general string type.
if 'body_name' in dataset:
assert set(dataset['body_name'].data) <= {body.name for body in bodies}, \
"Some body named in the dataset was not given as argument to `problems_from_dataset`."
body_range = {body.name: body for body in bodies if body.name in dataset['body_name'].data}
# Only the bodies listed in the dataset have been kept
else:
body_range = {body.name: body for body in bodies}
problems = []
if wave_direction_range is not None:
for omega, wave_direction, water_depth, body_name, rho \
in product(omega_range, wave_direction_range, water_depth_range, body_range, rho_range):
problems.append(
DiffractionProblem(body=body_range[body_name], omega=omega,
wave_direction=wave_direction, sea_bottom=-water_depth, rho=rho)
)
if radiating_dofs is not None:
for omega, radiating_dof, water_depth, body_name, rho \
in product(omega_range, radiating_dofs, water_depth_range, body_range, rho_range):
problems.append(
RadiationProblem(body=body_range[body_name], omega=omega,
radiating_dof=radiating_dof, sea_bottom=-water_depth, rho=rho)
)
return sorted(problems)
def test_results():
assert isinstance(LinearPotentialFlowProblem().make_results_container(), LinearPotentialFlowResult)
pb = DiffractionProblem(g=10, rho=1023, free_surface=np.infty)
res = DiffractionResult(pb)
assert res.g == pb.g == 10
assert "DiffractionResult" in str(res)
pb = RadiationProblem(g=10, rho=1023, free_surface=np.infty)
res = RadiationResult(pb)
assert res.g == pb.g == 10
assert "RadiationResult" in str(res)
def test_assemble_dataset():
body = Sphere(center=(0, 0, -4), name="sphere")
body.add_translation_dof(name="Heave")
pb_1 = DiffractionProblem(body=body, wave_direction=1.0, omega=1.0)
res_1 = solver.solve(pb_1)
ds1 = assemble_dataset([res_1])
assert "Froude_Krylov_force" in ds1
pb_2 = RadiationProblem(body=body, radiating_dof="Heave", omega=1.0)
res_2 = solver.solve(pb_2)
ds2 = assemble_dataset([res_2])
assert "added_mass" in ds2
ds12 = assemble_dataset([res_1, res_2])
assert "Froude_Krylov_force" in ds12
assert "added_mass" in ds12
def test_diffraction_problem():
assert DiffractionProblem().body is None
sphere = Sphere(radius=1.0, ntheta=20, nphi=40)
sphere.add_translation_dof(direction=(0, 0, 1), name="Heave")
pb = DiffractionProblem(body=sphere, wave_direction=1.0)
assert len(pb.boundary_condition) == sphere.mesh.nb_faces
with pytest.raises(TypeError):
DiffractionProblem(boundary_conditions=[0, 0, 0])
assert "DiffractionProblem" in str(DiffractionProblem(g=10, rho=1025, free_surface=np.infty))
res = pb.make_results_container()
assert isinstance(res, DiffractionResult)
def import_cal_file(filepath):
"""Read a Nemoh.cal file and return a list of problems."""
with open(filepath, 'r') as cal_file:
cal_file.readline() # Unused line.
rho = float(cal_file.readline().split()[0])
g = float(cal_file.readline().split()[0])
depth = float(cal_file.readline().split()[0])
if depth == 0.0:
sea_bottom = -np.infty
else:
sea_bottom = -depth
xeff, yeff = (float(x) for x in cal_file.readline().split()[0:2])
bodies = []
cal_file.readline() # Unused line.
nb_bodies = int(cal_file.readline().split()[0])
for _ in range(nb_bodies):
cal_file.readline() # Unused line.
mesh_file = cal_file.readline().split()[0].strip()
mesh_file = os.path.join(
os.path.dirname(filepath),
mesh_file) # mesh path are relative to Nemoh.cal
cal_file.readline() # Number of points, number of panels (unused)
if os.path.splitext(mesh_file)[1] == '.py':
from importlib.util import spec_from_file_location, module_from_spec
spec = spec_from_file_location("body_initialization_module",
mesh_file)
body_initialization = module_from_spec(spec)
spec.loader.exec_module(body_initialization)
body = body_initialization.body
else:
body = FloatingBody.from_file(mesh_file)
nb_dofs = int(cal_file.readline().split()[0])
for i_dof in range(nb_dofs):
dof_data = cal_file.readline().split()
if int(dof_data[0]) == 1:
direction = np.array([float(x) for x in dof_data[1:4]])
body.add_translation_dof(direction=direction)
elif int(dof_data[0]) == 2:
direction = np.array([float(x) for x in dof_data[1:4]])
center_of_mass = np.array(
[float(x) for x in dof_data[4:7]])
body.add_rotation_dof(
Axis(vector=direction, point=center_of_mass))
nb_forces = int(cal_file.readline().split()[0])
for i_force in range(nb_forces):
force_data = cal_file.readline().split()
if int(force_data[0]) == 1:
direction = np.array([float(x) for x in force_data[1:4]])
elif int(force_data[0]) == 2:
direction = np.array([float(x) for x in force_data[1:4]])
center_of_mass = np.array(
[float(x) for x in force_data[4:7]])
# TODO: use the generalized forces.
nb_additional_lines = int(cal_file.readline().split()[0])
for _ in range(nb_additional_lines):
cal_file.readline() # The additional lines are just ignored.
bodies.append(body)
if nb_bodies > 1:
bodies = FloatingBody.join_bodies(*bodies)
else:
bodies = bodies[0]
cal_file.readline() # Unused line.
frequency_data = cal_file.readline().split()
omega_range = np.linspace(float(frequency_data[1]),
float(frequency_data[2]),
int(frequency_data[0]))
direction_data = cal_file.readline().split()
direction_range = np.linspace(float(direction_data[1]),
float(direction_data[2]),
int(direction_data[0]))
direction_range = np.pi / 180 * direction_range # conversion from degrees to radians.
# The options below are not implemented yet.
cal_file.readline() # Unused line.
irf_data = cal_file.readline()
show_pressure = cal_file.readline().split()[0] == "1"
kochin_data = cal_file.readline().split()
kochin_range = np.linspace(float(kochin_data[1]),
float(kochin_data[2]), int(kochin_data[0]))
free_surface_data = cal_file.readline().split()
# Generate Capytaine's problem objects
env_args = dict(body=bodies, rho=rho, sea_bottom=sea_bottom, g=g)
problems = []
for omega in omega_range:
for direction in direction_range:
problems.append(
DiffractionProblem(wave_direction=direction,
omega=omega,
**env_args))
for dof in bodies.dofs:
problems.append(
RadiationProblem(radiating_dof=dof, omega=omega, **env_args))
return problems
def test_wamit_convention():
sphere = Sphere()
pb1 = DiffractionProblem(body=sphere, convention="Nemoh")
pb2 = DiffractionProblem(body=sphere, convention="WAMIT")
assert np.allclose(pb1.boundary_condition, np.conjugate(pb2.boundary_condition))
def problems_from_dataset(dataset: xr.Dataset,
bodies: Union[FloatingBody, Sequence[FloatingBody]],
) -> List[LinearPotentialFlowProblem]:
"""Generate a list of problems from a test matrix.
Parameters
----------
dataset : xarray Dataset
Test matrix containing the problems parameters.
bodies : FloatingBody or list of FloatingBody
The bodies on which the computations of the test matrix will be applied.
They should all have different names.
Returns
-------
list of LinearPotentialFlowProblem
Raises
------
ValueError
if required fields are missing in the dataset
"""
if isinstance(bodies, FloatingBody):
bodies = [bodies]
# SANITY CHECKS
assert len(list(set(body.name for body in bodies))) == len(bodies), \
"All bodies should have different names."
# Warn user in case of key with unrecognized name (e.g. mispells)
keys_in_dataset = set(dataset.keys()) | set(dataset.coords.keys())
accepted_keys = {'wave_direction', 'radiating_dof', 'body_name', 'omega', 'water_depth', 'rho', 'g'}
unrecognized_keys = keys_in_dataset.difference(accepted_keys)
if len(unrecognized_keys) > 0:
LOG.warning(f"Unrecognized key(s) in dataset: {unrecognized_keys}")
if ("radiating_dof" not in keys_in_dataset) and ("wave_direction" not in keys_in_dataset):
raise ValueError("Neither 'radiating_dof' nor 'wave_direction' has been provided in the dataset. "
"No linear potential flow problem can be inferred.")
# END SANITY CHECKS
dataset = _unsqueeze_dimensions(dataset)
omega_range = dataset['omega'].data if 'omega' in dataset else [_default_parameters['omega']]
water_depth_range = dataset['water_depth'].data if 'water_depth' in dataset else [_default_parameters['water_depth']]
rho_range = dataset['rho'].data if 'rho' in dataset else [_default_parameters['rho']]
g_range = dataset['g'].data if 'g' in dataset else [_default_parameters['g']]
wave_direction_range = dataset['wave_direction'].data if 'wave_direction' in dataset else None
radiating_dofs = dataset['radiating_dof'].data.astype(object) if 'radiating_dof' in dataset else None
# astype(object) is meant to convert Numpy internal string type numpy.str_ to Python general string type.
if 'body_name' in dataset:
assert set(dataset['body_name'].data) <= {body.name for body in bodies}, \
"Some body named in the dataset was not given as argument to `problems_from_dataset`."
body_range = {body.name: body for body in bodies if body.name in dataset['body_name'].data}
# Only the bodies listed in the dataset have been kept
else:
body_range = {body.name: body for body in bodies}
problems = []
if wave_direction_range is not None:
for omega, wave_direction, water_depth, body_name, rho, g \
in product(omega_range, wave_direction_range, water_depth_range, body_range, rho_range, g_range):
problems.append(
DiffractionProblem(body=body_range[body_name], omega=omega,
wave_direction=wave_direction, sea_bottom=-water_depth, rho=rho, g=g)
)
if radiating_dofs is not None:
for omega, radiating_dof, water_depth, body_name, rho, g \
in product(omega_range, radiating_dofs, water_depth_range, body_range, rho_range, g_range):
problems.append(
RadiationProblem(body=body_range[body_name], omega=omega,
radiating_dof=radiating_dof, sea_bottom=-water_depth, rho=rho, g=g)
)
return sorted(problems)
