def write_bem(self, fpath:str=None):
"""
Write the BEM solution to netCDF file
Parameters
----------
fpath : str, optional
DESCRIPTION. The default is the WEC's wrk_dir.
"""
if fpath is None:
fpath = os.path.join(self.params['wrk_dir'], self.params['name'] + '.nc')
assert isinstance(fpath, str), 'fpath must be type(str), received {:}'.format(type(fpath))
separate_complex_values(self.hydro).to_netcdf(fpath)
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 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_remove_complex_values():
original_dataset = xr.Dataset(
data_vars={
'variable1': (['x', 'y'], np.random.rand(4, 5)),
'variable2': (['x', 'y', 'z'], np.random.rand(4, 5, 3) + 1j * np.random.rand(4, 5, 3)),
'variable3': (['y', 'z'], np.random.rand(5, 3) + 1j * np.random.rand(5, 3)),
},
coords={
'x': (['x'], np.linspace(0, 10, 4))
})
real_dataset = separate_complex_values(original_dataset)
assert np.allclose(real_dataset['variable3'].sel(complex='re').data,
np.real(original_dataset['variable3'].data),
atol=0.1)
assert set(original_dataset.dims) == set(real_dataset.dims) - {'complex'}
complex_dataset = merge_complex_values(real_dataset)
assert set(original_dataset.dims) == set(complex_dataset.dims)
def generate_mesh() -> cpt.FloatingBody:
boat = cpt.FloatingBody.from_file(r"C:\data\docker\output.stl", file_format="stl", name="cheetah")
# boat.clip(Plane(normal=(0, 0, 1), point=(0, 0, -0.01))) # <-- optional, depending on the input mesh
boat.add_all_rigid_body_dofs()
boat.keep_immersed_part()
return boat
if __name__ == '__main__':
omega = [0.01, 0.02, 0.04,0.06,0.08,0.1,0.15, 0.2,0.25, 0.3,0.35, 0.4,0.45, 0.5,0.55, 0.6,0.65, 0.7, 0.8,0.9, 1.0,1.1,1.2,1.4,1.6,1.8,2.0,4.0]
body = generate_mesh()
# body = generate_boat()
body.show()
dataset = make_database(body=body, omegas=omega, wave_directions=np.linspace(0,pi,9))
print(dataset)
from capytaine.io.xarray import separate_complex_values
sep = separate_complex_values(dataset)
sep.to_netcdf(r"C:\data\python\rao\docs\examples\cheetah.nc",
encoding={'radiating_dof': {'dtype': 'U'},
'influenced_dof': {'dtype': 'U'},
'diffraction_result': {'dtype': 'U'}})