def test_get_environmental_interface(theme_menu, core, tidal_project,
var_tree):
theme_name = "Environmental Impact Assessment (Experimental)"
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
theme_menu.activate(core, project, theme_name)
project_menu.initiate_dataflow(core, project)
environmental_branch = var_tree.get_branch(core, project, theme_name)
environmental_branch.read_test_data(
core, project, os.path.join(dir_path, "inputs_environmental.pkl"))
environmental_branch.read_auto(core, project)
can_execute = theme_menu.is_executable(core, project, theme_name)
if not can_execute:
inputs = environmental_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "themes")
interface = connector.get_interface(core, project, theme_name)
#
assert interface.data.layout is not None
def test_get_electrical_interface(module_menu, core, tidal_project, var_tree):
mod_name = "Electrical Sub-Systems"
# project_menu = ProjectMenu()
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
electrical_branch = var_tree.get_branch(core, project, mod_name)
electrical_branch.read_test_data(core, project,
os.path.join(dir_path, "inputs_wp3.pkl"))
electrical_branch.read_auto(core, project)
can_execute = module_menu.is_executable(core, project, mod_name)
if not can_execute:
inputs = electrical_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "modules")
interface = connector.get_interface(core, project, mod_name)
assert interface.data.voltage is not None
def test_get_economics_interface(theme_menu, core, tidal_project, var_tree):
theme_name = "Economics"
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
theme_menu.activate(core, project, theme_name)
project_menu.initiate_dataflow(core, project)
economics_branch = var_tree.get_branch(core, project, theme_name)
economics_branch.read_test_data(
core, project, os.path.join(dir_path, "inputs_economics.pkl"))
economics_branch.read_auto(core, project)
can_execute = theme_menu.is_executable(core, project, theme_name)
if not can_execute:
inputs = economics_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "themes")
interface = connector.get_interface(core, project, theme_name)
assert interface.data.electrical_bom is not None
def test_ArrayLeasePlot_available(core, project, tree):
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
mod_name = "Mock Module"
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
mod_branch = tree.get_branch(core, project, mod_name)
mod_branch.read_test_data(core,
project,
os.path.join(dir_path, "inputs_wp3.pkl"))
# Force addition of lease area
lease_area = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])
core.add_datastate(project,
identifiers=["site.lease_boundary"],
values=[lease_area])
layout = mod_branch.get_input_variable(core, project, "project.layout")
result = layout.get_available_plots(core, project)
assert "Lease Area Array Layout" in result
def test_WaveOccurrencePlot(core, project, tree):
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
mod_name = "Mock Module"
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
# Force addition of occurance matrix
occurrence_matrix_coords = [[0., 1],
[0., 1],
[0., 1]]
matrix_xgrid = {"values": np.ones([2, 2, 2]),
"coords": occurrence_matrix_coords}
core.add_datastate(project,
identifiers=["farm.wave_occurrence"],
values=[matrix_xgrid])
mod_branch = tree.get_branch(core, project, mod_name)
wave_occurrence = mod_branch.get_output_variable(core,
project,
"farm.wave_occurrence")
wave_occurrence.plot(core, project, "Wave Resource Occurrence Matrix")
assert len(plt.get_fignums()) == 1
plt.close("all")
def test_PowerMatrixPlot(core, project, tree):
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
mod_name = "Mock Module"
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
# Force addition of power matrix
power_matrix_coords = [[0., 1],
[0., 1],
[0., 1]]
matrix_xgrid = {"values": np.ones([2, 2, 2]),
"coords": power_matrix_coords}
core.add_datastate(project,
identifiers=["device.wave_power_matrix"],
values=[matrix_xgrid])
mod_branch = tree.get_branch(core, project, mod_name)
power_matrix = mod_branch.get_output_variable(core,
project,
'device.wave_power_matrix')
power_matrix.plot(core, project, "Single Wave Device Power Matrix")
assert len(plt.get_fignums()) == 1
plt.close("all")
def test_DesignBoundaryPlot(core, project, tree):
project = deepcopy(project)
module_menu = ModuleMenu()
module_menu.activate(core, project, "Mock Module")
project_menu = ProjectMenu()
project_menu.initiate_dataflow(core, project)
installation_branch = tree.get_branch(core, project, "Mock Module")
installation_branch.read_test_data(
core, project, os.path.join(dir_path, "inputs_boundary.pkl"))
installation_branch.read_auto(core, project)
# Add nogo area
nogo_area = {"test": Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])}
core.add_datastate(project,
identifiers=["farm.nogo_areas", "corridor.nogo_areas"],
values=[nogo_area, nogo_area])
lease_entry = installation_branch.get_input_variable(
core, project, "project.lease_area_entry_point")
lease_entry.plot(core, project, "Design Boundaries")
assert len(plt.get_fignums()) == 1
plt.close("all")
def test_get_reliability_interface(theme_menu, core, tidal_project, var_tree):
theme_name = "Reliability"
# project_menu = ProjectMenu()
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
theme_menu.activate(core, project, theme_name)
project_menu.initiate_dataflow(core, project)
reliability_branch = var_tree.get_branch(core, project, theme_name)
reliability_branch.read_test_data(
core, project, os.path.join(dir_path, "inputs_reliability.pkl"))
reliability_branch.read_auto(core, project)
can_execute = theme_menu.is_executable(core, project, theme_name)
if not can_execute:
inputs = reliability_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "themes")
interface = connector.get_interface(core, project, theme_name)
assert interface.data.mission_time is not None
def test_auto_file_read(core, project, tree):
mod_name = "Mock Module"
var_id = "device.turbine_performance"
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
hydro_branch = tree.get_branch(core,
project,
mod_name)
new_var = hydro_branch.get_input_variable(core, project, var_id)
new_var.read_file(core,
project,
os.path.join(data_dir,
"tidal_performance.csv"))
inputs = hydro_branch.get_input_status(core, project)
assert inputs[var_id] == 'satisfied'
def test_get_installation_interface(module_menu, core, tidal_project,
var_tree):
mod_name = "Installation"
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
installation_branch = var_tree.get_branch(core, project, mod_name)
installation_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_wp5.pkl"))
installation_branch.read_auto(core, project)
can_execute = module_menu.is_executable(core, project, mod_name)
if not can_execute:
inputs = installation_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "modules")
interface = connector.get_interface(core,
project,
mod_name)
assert interface.data.site is not None
def test_get_maintenance_interface(module_menu, core, wave_project, var_tree):
mod_name = 'Operations and Maintenance'
project_menu = ProjectMenu()
project = deepcopy(wave_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
operations_branch = var_tree.get_branch(core, project, mod_name)
operations_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_wp6.pkl"))
operations_branch.read_auto(core, project)
can_execute = module_menu.is_executable(core, project, mod_name)
if not can_execute:
inputs = operations_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "modules")
interface = connector.get_interface(core,
project,
mod_name)
assert interface.data.system_type is not None
def test_dump_datastate_archive(core, project, var_tree, tmpdir):
project = deepcopy(project)
project_menu = ProjectMenu()
module_menu = ModuleMenu()
theme_menu = ThemeMenu()
module_menu.activate(core, project, "Mock Module")
theme_menu.activate(core, project, "Mock Theme")
project_menu.initiate_dataflow(core, project)
hydro_branch = var_tree.get_branch(core, project, "Mock Module")
hydro_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_wp2_tidal.pkl"))
eco_branch = var_tree.get_branch(core, project, "Mock Theme")
eco_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_economics.pkl"))
datastate_file_name = "my_datastate.dts"
datastate_file_path = os.path.join(str(tmpdir), datastate_file_name)
core.dump_datastate(project, datastate_file_path)
assert os.path.isfile(datastate_file_path)
def test_execute_output_level(core, var_tree):
project_title = "Test"
project_menu = ProjectMenu()
new_project = project_menu.new_project(core, project_title)
options_branch = var_tree.get_branch(core,
new_project,
"System Type Selection")
device_type = options_branch.get_input_variable(core,
new_project,
"device.system_type")
device_type.set_raw_interface(core, "Tidal Fixed")
device_type.read(core, new_project)
project_menu._execute(core,
new_project,
"System Type Selection")
current_sim = new_project.get_simulation()
output_level = "System Type Selection {}".format(core._markers["output"])
assert current_sim._execution_level == output_level.lower()
def test_auto_write_file(core, project, tree):
mod_name = "Mock Module"
var_id = "device.turbine_performance"
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
hydro_branch = tree.get_branch(core,
project,
mod_name)
new_var = hydro_branch.get_input_variable(core, project, var_id)
new_var.set_file_interface(core, os.path.join(data_dir,
"tidal_performance.csv"))
new_var.read(core, project)
output_path = os.path.join(data_dir,
"tidal_performance_copy.csv")
if os.path.exists(output_path): os.remove(output_path)
new_var.write_file(core,
project,
output_path)
assert os.path.exists(output_path)
def test_ArrayLeasePlotNumbers(core, project, tree):
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
mod_name = "Mock Module"
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
mod_branch = tree.get_branch(core, project, mod_name)
mod_branch.read_test_data(core,
project,
os.path.join(dir_path, "inputs_wp3.pkl"))
# Force addition of lease area
lease_area = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])
core.add_datastate(project,
identifiers=["site.lease_boundary"],
values=[lease_area])
layout = mod_branch.get_input_variable(core, project, "project.layout")
layout.plot(core, project, "Lease Area Array Layout (With Device Numbers)")
assert len(plt.get_fignums()) == 1
plt.close("all")
def test_auto_plot(core, project, tree):
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
mod_name = "Mock Module"
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
hydro_branch = tree.get_branch(core,
project,
mod_name)
hydro_branch.read_test_data(core,
project,
os.path.join(this_dir,
"inputs_wp2_tidal.pkl"))
cp_curve = hydro_branch.get_input_variable(core,
project,
"device.turbine_performance")
cp_curve.plot(core, project)
assert len(plt.get_fignums()) == 1
plt.close("all")
def test_get_tidal_interface(module_menu, core, tidal_project, var_tree):
mod_name = "Hydrodynamics"
# project_menu = ProjectMenu()
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
hydro_branch = var_tree.get_branch(core, project, mod_name)
hydro_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_wp2_tidal.pkl"))
can_execute = module_menu.is_executable(core, project, mod_name)
if not can_execute:
inputs = hydro_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "modules")
interface = connector.get_interface(core,
project,
mod_name)
assert interface.data.perf_curves is not None
def project(core, tree):
'''Share a Project object'''
project_title = "Test"
project_menu = ProjectMenu()
new_project = project_menu.new_project(core, project_title)
options_branch = tree.get_branch(core, new_project,
"System Type Selection")
device_type = options_branch.get_input_variable(core, new_project,
"device.system_type")
device_type.set_raw_interface(core, "Tidal Fixed")
device_type.read(core, new_project)
project_menu.initiate_pipeline(core, new_project)
project_menu.activate(core, new_project, "Site Boundary Selection")
boundaries_branch = tree.get_branch(core, new_project,
"Site Boundary Selection")
boundaries_branch.read_test_data(
core, new_project, os.path.join(dir_path, "inputs_boundary.pkl"))
project_menu._execute(core,
new_project,
"Site Boundary Selection",
set_output_level=False)
return new_project
def test_ArrayCablesPlot(core, project, tree):
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
mod_name = "Mock Module"
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
# Need to provide these inputs:
# "site.lease_boundary",
# "corridor.landing_point",
# "project.layout",
# "project.cable_routes",
# "project.substation_layout"
lease_area = Polygon([(0, 0), (20, 0), (20, 50), (0, 50)])
landing_point = [10, 0]
layout = {"device001": (10, 40)}
substation = {"array": [10, 20]}
cable_dict = {"Marker": [0, 0, 0, 1, 1, 1],
"UTM X": [10, 10, 10, 10, 10, 10],
"UTM Y": [40, 30, 20, 20, 10, 0],
"Key Identifier": [None, None, None, None, None, None],
"Depth": [None, None, None, None, None, None],
"Burial Depth": [None, None, None, None, None, None],
"Sediment": [None, None, None, None, None, None],
"Split Pipe": [None, None, None, None, None, None]}
cable_df = pd.DataFrame(cable_dict)
core.add_datastate(project,
identifiers=["site.lease_boundary",
"corridor.landing_point",
"project.layout",
"project.substation_layout",
"project.cable_routes"],
values=[lease_area,
landing_point,
layout,
substation,
cable_df])
mod_branch = tree.get_branch(core, project, mod_name)
cables = mod_branch.get_output_variable(core,
project,
"project.cable_routes")
cables.plot(core, project, "Array Cable Layout")
assert len(plt.get_fignums()) == 1
plt.close("all")
def test_NumpyLine_has_plot(core, project):
project = deepcopy(project)
module_menu = ModuleMenu()
project_menu = ProjectMenu()
module_menu.activate(core, project, "Mock Module")
project_menu.initiate_dataflow(core, project)
test = InputVariable("device.turbine_performance")
result = test._find_receiving_interface(core, "AutoPlot")
assert 'device.turbine_performance AutoPlot Interface' == result.get_name()
def test_filter_interface(core, project, tree):
project = deepcopy(project)
data_menu = DataMenu()
module_menu = ModuleMenu()
project_menu = ProjectMenu()
tree = Tree()
data_menu.select_database(project, "local")
project_menu.initiate_pipeline(core, project)
project_menu.initiate_options(core, project)
filter_branch = tree.get_branch(core, project,
'Database Filtering Interface')
new_var = filter_branch.get_input_variable(core, project,
"device.selected_name")
new_var.set_raw_interface(core, "ExampleWaveDevice")
new_var.read(core, project)
module_menu.activate(core, project, "Hydrodynamics")
project_menu.initiate_filter(core, project)
assert True
def test_dump_datastate_nodir(core, project, var_tree):
project = deepcopy(project)
project_menu = ProjectMenu()
module_menu = ModuleMenu()
theme_menu = ThemeMenu()
module_menu.activate(core, project, "Mock Module")
theme_menu.activate(core, project, "Mock Theme")
project_menu.initiate_dataflow(core, project)
with pytest.raises(ValueError):
core.dump_datastate(project, "some_path")
def test_economics_inputs(theme_menu, core, tidal_project, var_tree):
theme_name = "Economics"
data_menu = DataMenu()
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
theme_menu.activate(core, project, theme_name)
project_menu.initiate_dataflow(core, project)
data_menu.load_data(core, project)
economics_branch = var_tree.get_branch(core, project, theme_name)
economics_input_status = economics_branch.get_input_status(core, project)
assert "project.estimate_energy_record" in economics_input_status
def test_moorings_inputs(module_menu, core, tidal_project, var_tree):
mod_name = "Mooring and Foundations"
data_menu = DataMenu()
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
data_menu.load_data(core, project)
moorings_branch = var_tree.get_branch(core, project, mod_name)
moorings_input_status = moorings_branch.get_input_status(core, project)
assert "device.dry_beam_area" in moorings_input_status
def wave_project(core):
'''Share a Project object'''
project_menu = ProjectMenu()
var_tree = Tree()
new_project = project_menu.new_project(core, "test wave")
options_branch = var_tree.get_branch(core, new_project,
"System Type Selection")
device_type = options_branch.get_input_variable(core, new_project,
"device.system_type")
device_type.set_raw_interface(core, "Wave Floating")
device_type.read(core, new_project)
return new_project
def test_load_project_archive(core, project, var_tree, tmpdir):
project = deepcopy(project)
project_menu = ProjectMenu()
module_menu = ModuleMenu()
theme_menu = ThemeMenu()
module_menu.activate(core, project, "Mock Module")
theme_menu.activate(core, project, "Mock Theme")
project_menu.initiate_dataflow(core, project)
hydro_branch = var_tree.get_branch(core, project, "Mock Module")
hydro_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_wp2_tidal.pkl"))
eco_branch = var_tree.get_branch(core, project, "Mock Theme")
eco_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_economics.pkl"))
project_file_name = "my_project.prj"
project_file_path = os.path.join(str(tmpdir), project_file_name)
core.dump_project(project, project_file_path)
del(project)
assert os.path.isfile(project_file_path)
new_root = os.path.join(str(tmpdir), "test")
os.makedirs(new_root)
move_file_path = os.path.join(str(tmpdir), "test", project_file_name)
shutil.copy2(project_file_path, move_file_path)
loaded_project = core.load_project(move_file_path)
active_sim = loaded_project.get_simulation()
assert loaded_project.check_integrity()
assert active_sim.get_title() == "Default"
assert "Mock Module" in module_menu.get_scheduled(core, loaded_project)
def test_maintenance_interface_entry(module_menu,
core,
wave_project,
var_tree,
mocker,
tmpdir):
# Make a source directory with some files
config_tmpdir = tmpdir.mkdir("config")
mock_dir = Directory(str(config_tmpdir))
mocker.patch('dtocean_core.interfaces.maintenance.UserDataDirectory',
return_value=mock_dir,
autospec=True)
mod_name = 'Operations and Maintenance'
project_menu = ProjectMenu()
project = deepcopy(wave_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
operations_branch = var_tree.get_branch(core, project, mod_name)
operations_branch.read_test_data(core,
project,
os.path.join(dir_path,
"inputs_wp6.pkl"))
operations_branch.read_auto(core, project)
can_execute = module_menu.is_executable(core, project, mod_name)
if not can_execute:
inputs = operations_branch.get_input_status(core, project)
pprint(inputs)
assert can_execute
connector = _get_connector(project, "modules")
interface = connector.get_interface(core,
project,
mod_name)
interface.connect(debug_entry=True)
debugdir = config_tmpdir.join("..", "debug")
assert len(debugdir.listdir()) == 1
def test_load_datastate_archive(core, project, var_tree, tmpdir):
temp_project = deepcopy(project)
project_menu = ProjectMenu()
module_menu = ModuleMenu()
theme_menu = ThemeMenu()
module_menu.activate(core, temp_project, "Mock Module")
theme_menu.activate(core, temp_project, "Mock Theme")
project_menu.initiate_dataflow(core, temp_project)
hydro_branch = var_tree.get_branch(core, temp_project, "Mock Module")
hydro_branch.read_test_data(core,
temp_project,
os.path.join(dir_path,
"inputs_wp2_tidal.pkl"))
eco_branch = var_tree.get_branch(core, temp_project, "Mock Theme")
eco_branch.read_test_data(core,
temp_project,
os.path.join(dir_path,
"inputs_economics.pkl"))
datastate_file_name = "my_datastate.dts"
datastate_file_path = os.path.join(str(tmpdir), datastate_file_name)
core.dump_datastate(temp_project, datastate_file_path)
del(temp_project)
assert os.path.isfile(datastate_file_path)
new_root = os.path.join(str(tmpdir), "test")
os.makedirs(new_root)
move_file_path = os.path.join(str(tmpdir), "test", datastate_file_name)
shutil.copy2(datastate_file_path, move_file_path)
temp_project = deepcopy(project)
project_menu = ProjectMenu()
module_menu = ModuleMenu()
theme_menu = ThemeMenu()
module_menu.activate(core, temp_project, "Mock Module")
project_menu.initiate_dataflow(core, temp_project)
assert not core.has_data(temp_project, "device.turbine_interdistance")
core.load_datastate(temp_project, move_file_path)
assert temp_project.check_integrity()
assert core.has_data(temp_project, "device.turbine_interdistance")
def test_electrical_inputs(module_menu, core, tidal_project, var_tree):
mod_name = "Electrical Sub-Systems"
# project_menu = ProjectMenu()
data_menu = DataMenu()
project_menu = ProjectMenu()
project = deepcopy(tidal_project)
module_menu.activate(core, project, mod_name)
project_menu.initiate_dataflow(core, project)
data_menu.load_data(core, project)
electrical_branch = var_tree.get_branch(core, project, mod_name)
electrical_input_status = electrical_branch.get_input_status(core, project)
assert "component.transformers" in electrical_input_status
def tidal_project(core, var_tree):
'''Share a Project object'''
project_menu = ProjectMenu()
new_project = project_menu.new_project(core, "test tidal")
options_branch = var_tree.get_branch(core, new_project,
"System Type Selection")
device_type = options_branch.get_input_variable(core, new_project,
"device.system_type")
device_type.set_raw_interface(core, "Tidal Fixed")
device_type.read(core, new_project)
project_menu.initiate_pipeline(core, new_project)
return new_project
