def test_write_outputs():
problem = FASTOADProblem()
problem.model.add_subsystem("sellar", Sellar(), promotes=["*"])
problem.output_file_path = pth.join(RESULTS_FOLDER_PATH, "output.xml")
problem.setup()
problem.write_outputs()
variables = VariableIO(problem.output_file_path).read()
assert variables == [
Variable(name="f", value=1.0),
Variable(name="g1", value=1.0),
Variable(name="g2", value=1.0),
Variable(name="x", value=2),
Variable(name="y2", value=1.0),
Variable(name="z", value=[5.0, 2.0], units="m**2"),
]
problem.run_model()
problem.write_outputs()
variables = VariableIO(problem.output_file_path).read()
assert variables == [
Variable(name="f", value=32.569100892077444),
Variable(name="g1", value=-23.409095627564167),
Variable(name="g2", value=-11.845478137832359),
Variable(name="x", value=2),
Variable(name="y2", value=12.154521862167641),
Variable(name="z", value=[5.0, 2.0], units="m**2"),
]
def get_problem(self,
read_inputs: bool = False,
auto_scaling: bool = False) -> FASTOADProblem:
"""
Builds the OpenMDAO problem from current configuration.
:param read_inputs: if True, the created problem will already be fed
with variables from the input file
:param auto_scaling: if True, automatic scaling is performed for design
variables and constraints
:return: the problem instance
"""
if not self._conf_dict:
raise RuntimeError("read configuration file first")
problem = FASTOADProblem(self._build_model())
problem.input_file_path = self.input_file_path
problem.output_file_path = self.output_file_path
driver = self._conf_dict.get(KEY_DRIVER, "")
if driver:
problem.driver = _om_eval(driver)
if self.get_optimization_definition():
self._add_constraints(problem.model, auto_scaling)
self._add_objectives(problem.model)
if read_inputs:
problem.read_inputs()
self._add_design_vars(problem.model, auto_scaling)
return problem
def patched_function(inputs_dict: dict) -> dict:
"""
The patched function perform a run of an openmdao component or group applying FASTOAD formalism.
@param inputs_dict: dictionary of input (values, units) saved with their key name,
as an example: inputs_dict = {'in1': (3.0, "m")}.
@return: dictionary of the component/group outputs saving names as keys and (value, units) as tuple.
"""
# Read .xml file and construct Independent Variable Component excluding outputs
reader.path_separator = ":"
ivc_local = reader.to_ivc()
for name, value in inputs_dict.items():
ivc_local.add_output(name, value[0], units=value[1])
group_local = AutoUnitsDefaultGroup()
group_local.add_subsystem('system', system, promotes=["*"])
group_local.add_subsystem('ivc', ivc_local, promotes=["*"])
problem_local = FASTOADProblem(group_local)
problem_local.setup()
problem_local.run_model()
if overwrite:
problem_local.output_file_path = xml_file_path
problem_local.write_outputs()
# Get output names from component/group and construct dictionary
outputs_units = [var.units for var in variables if not var.is_input]
outputs_dict = {}
for idx in range(len(outputs_names)):
value = problem_local.get_val(outputs_names[idx], outputs_units[idx])
outputs_dict[outputs_names[idx]] = (value, outputs_units[idx])
return outputs_dict
def test_write_outputs():
problem = FASTOADProblem()
problem.model.add_subsystem("sellar", Sellar(), promotes=["*"])
problem.output_file_path = pth.join(RESULTS_FOLDER_PATH, "output.xml")
problem.setup()
problem.write_outputs()
variables = VariableIO(problem.output_file_path).read()
assert variables == [
Variable(name="f", val=1.0),
Variable(name="g1", val=1.0),
Variable(name="g2", val=1.0),
Variable(name="x", val=2.0),
Variable(name="y2", val=1.0),
Variable(name="z", val=[np.nan, np.nan], units="m**2"),
]
problem["x"] = 2.0
problem["z"] = [
5.0,
2.0,
] # Since version 3.17 of OpenMDAO, the np.nan input definition of z is chosen.
problem.run_model()
problem.write_outputs()
variables = VariableIO(problem.output_file_path).read()
assert variables == [
Variable(name="f", val=32.569100892077444),
Variable(name="g1", val=-23.409095627564167),
Variable(name="g2", val=-11.845478137832359),
Variable(name="x", val=2.0),
Variable(name="y2", val=12.154521862167641),
Variable(name="z", val=[5.0, 2.0], units="m**2"),
]
def get_problem(self,
read_inputs: bool = False,
auto_scaling: bool = False) -> FASTOADProblem:
"""
Builds the OpenMDAO problem from current configuration.
:param read_inputs: if True, the created problem will already be fed
with variables from the input file
:param auto_scaling: if True, automatic scaling is performed for design
variables and constraints
:return: the problem instance
"""
if self._serializer.data is None:
raise RuntimeError("read configuration file first")
if read_inputs:
problem_with_no_inputs = self.get_problem(
auto_scaling=auto_scaling)
problem_with_no_inputs.setup()
input_ivc, unused_variables = self._get_problem_inputs(
problem_with_no_inputs)
else:
input_ivc = unused_variables = None
problem = FASTOADProblem(self._build_model(input_ivc))
problem.input_file_path = self.input_file_path
problem.output_file_path = self.output_file_path
problem.additional_variables = unused_variables
driver = self._serializer.data.get(KEY_DRIVER, "")
if driver:
problem.driver = _om_eval(driver)
if self.get_optimization_definition():
self._add_constraints(problem.model, auto_scaling)
self._add_objectives(problem.model)
if read_inputs:
self._add_design_vars(problem.model, auto_scaling)
if self._configuration_modifier:
self._configuration_modifier.modify(problem)
return problem
def generate_block_analysis(
system: Union[ExplicitComponent, ImplicitComponent, Group],
var_inputs: List,
xml_file_path: str,
overwrite: bool = False,
):
# Search what are the component/group outputs
variables = list_variables(system)
inputs_names = [var.name for var in variables if var.is_input]
outputs_names = [var.name for var in variables if not var.is_input]
# Check that variable inputs are in the group/component list
if not(set(var_inputs) == set(inputs_names).intersection(set(var_inputs))):
raise Exception('The input list contains name(s) out of component/group input list!')
# Perform some tests on the .xml availability and completeness
if not(os.path.exists(xml_file_path)) and not(set(var_inputs) == set(inputs_names)):
# If no input file and some inputs are missing, generate it and return None
if isinstance(system, Group):
problem = FASTOADProblem(system)
else:
group = AutoUnitsDefaultGroup()
group.add_subsystem('system', system, promotes=["*"])
problem = FASTOADProblem(group)
problem.input_file_path = xml_file_path
problem.setup()
problem.write_needed_inputs(None, VariableXmlStandardFormatter())
raise Exception('Input .xml file not found, a default file has been created with default NaN values, '
'but no function is returned!\nConsider defining proper values before second execution!')
elif os.path.exists(xml_file_path):
reader = VariableIO(xml_file_path, VariableXmlStandardFormatter()).read(ignore=(var_inputs + outputs_names))
xml_inputs = reader.names()
if not(set(xml_inputs + var_inputs).intersection(set(inputs_names)) == set(inputs_names)):
# If some inputs are missing write an error message and add them to the problem if authorized
missing_inputs = list(
set(inputs_names).difference(set(xml_inputs + var_inputs).intersection(set(inputs_names)))
)
message = 'The following inputs are missing in .xml file:'
for item in missing_inputs:
message += ' [' + item + '],'
message = message[:-1] + '.\n'
if overwrite:
reader.path_separator = ":"
ivc = reader.to_ivc()
group = AutoUnitsDefaultGroup()
group.add_subsystem('system', system, promotes=["*"])
group.add_subsystem('ivc', ivc, promotes=["*"])
problem = FASTOADProblem(group)
problem.input_file_path = xml_file_path
problem.output_file_path = xml_file_path
problem.setup()
problem.write_outputs()
message += 'Default values have been added to {} file. ' \
'Consider modifying them for a second run!'.format(xml_file_path)
raise Exception(message)
else:
raise Exception(message)
else:
# If all inputs addressed either by .xml or var_inputs, construct the function
def patched_function(inputs_dict: dict) -> dict:
"""
The patched function perform a run of an openmdao component or group applying FASTOAD formalism.
@param inputs_dict: dictionary of input (values, units) saved with their key name,
as an example: inputs_dict = {'in1': (3.0, "m")}.
@return: dictionary of the component/group outputs saving names as keys and (value, units) as tuple.
"""
# Read .xml file and construct Independent Variable Component excluding outputs
reader.path_separator = ":"
ivc_local = reader.to_ivc()
for name, value in inputs_dict.items():
ivc_local.add_output(name, value[0], units=value[1])
group_local = AutoUnitsDefaultGroup()
group_local.add_subsystem('system', system, promotes=["*"])
group_local.add_subsystem('ivc', ivc_local, promotes=["*"])
problem_local = FASTOADProblem(group_local)
problem_local.setup()
problem_local.run_model()
if overwrite:
problem_local.output_file_path = xml_file_path
problem_local.write_outputs()
# Get output names from component/group and construct dictionary
outputs_units = [var.units for var in variables if not var.is_input]
outputs_dict = {}
for idx in range(len(outputs_names)):
value = problem_local.get_val(outputs_names[idx], outputs_units[idx])
outputs_dict[outputs_names[idx]] = (value, outputs_units[idx])
return outputs_dict
return patched_function