def evaluate_column_modal_response_amplitudes(self):
"""
"""
bem_solver = cpt.BEMSolver()
problems = [
cpt.RadiationProblem(sea_bottom=self.water_depth,
body=self.column_mesh,
radiating_dof=dof,
omega=omega) for dof in self.column_mesh.dofs
for omega in self.wave_frequencies
]
problems += [
cpt.DiffractionProblem(sea_bottom=self.water_depth,
body=self.column_mesh,
wave_direction=self.wave_direction,
omega=omega)
for omega in self.wave_frequencies
]
results = [bem_solver.solve(problem) for problem in problems]
result_data = cpt.assemble_dataset(results)
modal_response_amplitude_data = cpt.post_pro.rao(
result_data, wave_direction=self.wave_direction)
self.result_data = result_data
self.modal_response_amplitude_data = modal_response_amplitude_data
def test_dataset_from_bemio():
bemio = pytest.importorskip("bemio.io.wamit",
reason="Bemio not installed, test skipped.")
current_file_path = os.path.dirname(os.path.abspath(__file__))
out_file = os.path.join(current_file_path, "Bemio_verification_cases",
"sphere.out")
bemio_data = bemio.read(out_file)
new_dataset = cpt.assemble_dataset(bemio_data)
assert (np.moveaxis(bemio_data.body[0].am.all, 2, 0) * bemio_data.body[0].rho == \
new_dataset['added_mass'].values).all()
def evaluate_buoy_forces(buoy_object):
# Set up radiation and diffraction problems
problems = [cpt.RadiationProblem(body=buoy_object, radiating_dof=degree_of_freedom, omega=omega)
for omega in omega_range]
problems += [cpt.DiffractionProblem(omega=omega, body=buoy_object, wave_direction=wave_direction)
for omega in omega_range]
# Solve each matrix problem
solver = cpt.BEMSolver(engine=cpt.HierarchicalToeplitzMatrixEngine())
results = [solver.solve(pb) for pb in sorted(problems)]
return cpt.assemble_dataset(results)
def make_database(body, omegas, wave_directions):
# SOLVE BEM PROBLEMS
problems = []
for wave_direction in wave_directions:
for omega in omegas:
problems += [cpt.RadiationProblem(omega=omega, body=body, radiating_dof=dof) for dof in body.dofs]
problems += [cpt.DiffractionProblem(omega=omega, body=body, wave_direction=wave_direction)]
results = [bem_solver.solve(problem) for problem in problems]
*radiation_results, diffraction_result = results
dataset = cpt.assemble_dataset(results)
dataset['diffraction_result'] = diffraction_result
return dataset
def setup_animation(body, fs, omega, wave_amplitude,
wave_direction) -> Animation:
# SOLVE BEM PROBLEMS
problems = [
cpt.RadiationProblem(omega=omega, body=body, radiating_dof=dof)
for dof in body.dofs
]
problems += [
cpt.DiffractionProblem(omega=omega,
body=body,
wave_direction=wave_direction)
]
results = [bem_solver.solve(problem) for problem in problems]
*radiation_results, diffraction_result = results
dataset = cpt.assemble_dataset(results)
# COMPUTE RAO
dataset['RAO'] = cpt.post_pro.rao(dataset, wave_direction=wave_direction)
# Compute the motion of each face of the mesh for the animation
rao_faces_motion = sum(
dataset['RAO'].sel(omega=omega, radiating_dof=dof).data *
body.full_body.dofs[dof] for dof in body.dofs)
# COMPUTE FREE SURFACE ELEVATION
# Compute the diffracted wave pattern
diffraction_elevation = bem_solver.get_free_surface_elevation(
diffraction_result, fs)
incoming_waves_elevation = fs.incoming_waves(diffraction_result)
# Compute the wave pattern radiated by the RAO
radiation_elevations_per_dof = {
res.radiating_dof: bem_solver.get_free_surface_elevation(res, fs)
for res in radiation_results
}
rao_radiation_elevation = sum(
dataset['RAO'].sel(omega=omega, radiating_dof=dof).data *
radiation_elevations_per_dof[dof] for dof in body.dofs)
# SET UP ANIMATION
animation = Animation(loop_duration=2 * pi / omega)
animation.add_body(body.full_body,
faces_motion=wave_amplitude * rao_faces_motion)
animation.add_free_surface(
fs,
wave_amplitude * (incoming_waves_elevation + diffraction_elevation +
rao_radiation_elevation))
return animation
def solve_sim(sims, omegas):
"""Solve for all the directions of a single period
"""
bem_solver = cpt.BEMSolver()
i_sim = 0
for j, omega in enumerate(omegas):
radiation = [
bem_solver.solve(sims[i_sim + i]) for i in range(len(DOFS))]
i_sim += len(DOFS)
for i, d in enumerate(DIRS):
results = radiation[:]
results.append(bem_solver.solve(sims[i_sim]))
i_sim += 1
dataset = cpt.assemble_dataset(results)
yield i, j, cpt.post_pro.rao(dataset, wave_direction=d)
"""
def test_xarray_dataset_with_more_data():
# Store some mesh data when several bodies in dataset
bodies = [
cpt.Sphere(radius=1, ntheta=3, nphi=3, name="sphere_1"),
cpt.Sphere(radius=2, ntheta=5, nphi=3, name="sphere_2"),
cpt.Sphere(radius=3, ntheta=7, nphi=3, name="sphere_3"),
]
for body in bodies:
body.keep_immersed_part()
body.add_translation_dof(name="Heave")
problems = [cpt.RadiationProblem(body=b, radiating_dof="Heave", omega=1.0) for b in bodies]
results = cpt.BEMSolver().solve_all(problems)
ds = cpt.assemble_dataset(results, mesh=True)
assert 'nb_faces' in ds.coords
assert set(ds.coords['nb_faces'].values) == set([b.mesh.nb_faces for b in bodies])
def solve_tube_hydrodynamics(self):
"""
"""
#print('\tSolving tube hydrodynamics.')
solver = cpt.BEMSolver()
problems = [
cpt.RadiationProblem(omega=omega,
body=self.tube,
radiating_dof=dof,
rho=self.rho,
sea_bottom=self.water_depth)
for dof in self.tube.dofs for omega in self.wave_frequencies
]
problems += [
cpt.DiffractionProblem(omega=omega,
body=self.tube,
wave_direction=self.wave_direction,
rho=self.rho,
sea_bottom=self.water_depth)
for omega in self.wave_frequencies
]
results = solver.solve_all(problems, keep_details=False)
result_data = cpt.assemble_dataset(results)
if self.save_results:
from capytaine.io.xarray import separate_complex_values
save_file_name = 'flexible_tube_results__rs_le_zs__{:.2f}_{:.1f}_{:.2f}__with_{}_cells.nc' \
.format(self.static_radius, self.length, self.submergence, self.tube.mesh.nb_faces)
separate_complex_values(result_data).to_netcdf(
save_file_name,
encoding={
'radiating_dof': {
'dtype': 'U'
},
'influenced_dof': {
'dtype': 'U'
}
})
self.result_data = result_data
def test_rotation_axis():
body = cpt.RectangularParallelepiped(resolution=(4, 4, 4),
center=(0, 0, -1),
name="body")
body.add_translation_dof(name="Sway")
body.add_rotation_dof(axis=cpt.Axis(point=(0, 0, 0), vector=(0, 0, 1)),
name="Yaw")
l = 2.0
body.add_rotation_dof(axis=cpt.Axis(point=(l, 0, 0), vector=(0, 0, 1)),
name="other_rotation")
assert np.allclose(body.dofs['other_rotation'],
(body.dofs['Yaw'] - l * body.dofs['Sway']))
problems = [
cpt.RadiationProblem(body=body, radiating_dof=dof, omega=1.0)
for dof in body.dofs
]
solver = cpt.Nemoh()
results = solver.solve_all(problems, keep_details=True)
dataset = cpt.assemble_dataset(results)
sources = {result.radiating_dof: result.sources for result in results}
assert np.allclose(sources['other_rotation'],
sources['Yaw'] - l * sources['Sway'],
atol=1e-4)
potential = {result.radiating_dof: result.potential for result in results}
assert np.allclose(potential['other_rotation'],
potential['Yaw'] - l * potential['Sway'],
atol=1e-4)
A_m = dataset['added_mass'].sel(radiating_dof="other_rotation",
influenced_dof="other_rotation").data
A = dataset['added_mass'].sel(radiating_dof=["Yaw", "Sway"],
influenced_dof=["Yaw", "Sway"]).data
P = np.array([1, -l])
assert np.isclose(A_m, P.T @ A @ P)
def solve_beam_hydrodynamics(self, save_results):
"""
"""
bem_solver = cpt.BEMSolver()
problems = [
cpt.RadiationProblem(sea_bottom=self.water_depth,
body=self.beam_mesh,
radiating_dof=dof,
omega=omega) for dof in self.beam_mesh.dofs
for omega in self.wave_frequencies
]
problems += [
cpt.DiffractionProblem(sea_bottom=self.water_depth,
body=self.beam_mesh,
wave_direction=self.wave_direction,
omega=omega)
for omega in self.wave_frequencies
]
results = [bem_solver.solve(problem) for problem in problems]
result_data = cpt.assemble_dataset(results)
if save_results:
from capytaine.io.xarray import separate_complex_values
separate_complex_values(result_data).to_netcdf(
'beam_hydrodynamics_results.nc',
encoding={
'radiating_dof': {
'dtype': 'U'
},
'influenced_dof': {
'dtype': 'U'
}
})
return result_data
def test_sum_of_dofs():
body1 = cpt.Sphere(radius=1.0,
ntheta=3,
nphi=12,
center=(0, 0, -3),
name="body1")
body1.add_translation_dof(name="Heave")
body2 = cpt.Sphere(radius=1.0,
ntheta=3,
nphi=8,
center=(5, 3, -1.5),
name="body2")
body2.add_translation_dof(name="Heave")
both = body1 + body2
both.add_translation_dof(name="Heave")
problems = [
cpt.RadiationProblem(body=both, radiating_dof=dof, omega=1.0)
for dof in both.dofs
]
solver = cpt.Nemoh()
results = solver.solve_all(problems)
dataset = cpt.assemble_dataset(results)
both_added_mass = dataset['added_mass'].sel(radiating_dof="Heave",
influenced_dof="Heave").data
body1_added_mass = dataset['added_mass'].sel(
radiating_dof="body1__Heave", influenced_dof="body1__Heave").data
body2_added_mass = dataset['added_mass'].sel(
radiating_dof="body2__Heave", influenced_dof="body2__Heave").data
assert np.allclose(both_added_mass,
body1_added_mass + body2_added_mass,
rtol=1e-2)
wave_direction=heading,
sea_bottom=-np.infty,
g=9.81,
rho=1000.0) for w in freq for heading in directions
]
# 3. Define the BEM solver to be used.
solver = cpt.BEMSolver()
# 4. Loop through the problems and solve each
results = [
solver.solve(problem, keep_details=True) for problem in sorted(problems)
]
# 5. Create a dataset using the list of results and any hydrostatics output
capyData = cpt.assemble_dataset(results, hydrostatics=False)
###############################################################################
# ** Alternate method to 2-5
# Create a dataset of parameters.
# 'fill_dataset()' automatically creates problems and solves them.
# This method is easy and clean, but has less control on the problem details
test_matrix = xr.Dataset(
coords={
'omega': freq,
'wave_direction': directions,
'radiating_dof': list(body.dofs),
'water_depth': [np.infty],
})
dataset = solver.fill_dataset(test_matrix, [body], hydrostatics=False)
###############################################################################
# change omega values
omega = np.linspace(0.1, 2, 10)
wave_direction = 0.0
#body.keep_only_dofs(['Heave'])
problems = [
cpt.RadiationProblem(omega=w, body=body, radiating_dof=dof)
for dof in body.dofs for w in omega
]
problems += [
cpt.DiffractionProblem(omega=w, body=body, wave_direction=wave_direction)
for w in omega
]
results = [bem_solver.solve(problem) for problem in problems]
*radiation_results, diffraction_result = results
dataset = cpt.assemble_dataset(results)
# COMPUTE RAO
dataset['RAO'] = cpt.post_pro.rao(dataset, wave_direction=wave_direction)
# print(dataset['RAO'])
# print(dataset['RAO'].data)
#plt.plot(omega,dataset['RAO'].data)
#change dof to heave, pitch, surge
dof = "Heave"
plt.plot(omega, np.abs(dataset['RAO'].sel(radiating_dof=dof)))
plt.xlabel('omega')
plt.ylabel('RAO ' + dof)
plt.show()
