def test_turbine_Type_multistart_XYZ_optimization():
plot_comp = DummyCostPlotComp(optimal, delay=.5)
plot_comp = NoPlot()
xyz = [(0, 0, 0), (1, 1, 1)]
p1 = DummyCost(optimal_state=optimal,
inputs=['x', 'y', 'z', 'type'])
p2 = TurbineXYZOptimizationProblem(
cost_comp=p1,
turbineXYZ=xyz,
min_spacing=2,
boundary_comp=get_boundary_comp(),
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(disp=True, optimizer='COBYLA', maxiter=10))
p3 = InitialXYZOptimizationProblem(
cost_comp=p2,
turbineXYZ=xyz, min_spacing=2,
boundary_comp=get_boundary_comp(),
driver=DOEDriver(ListGenerator([[('x', [0, 4]), ('y', [2, 2]), ('z', [4, 1])]])))
tf = TurbineTypeOptimizationProblem(
cost_comp=p3,
turbineTypes=[0, 0], lower=0, upper=1,
driver=DOEDriver(FullFactorialGenerator(1)))
case_gen = tf.driver.options['generator']
cost, state, recorder = tf.optimize()
print(cost)
# print (state)
print(recorder.get('type'))
print(recorder.get('cost'))
best_index = np.argmin(recorder.get('cost'))
initial_xyz_recorder = recorder['recorder'][best_index]
xyz_recorder = initial_xyz_recorder.get('recorder')[0]
npt.assert_almost_equal(xyz_recorder['cost'][-1], cost)
def test_3level_type_multistart_XYZ_optimization():
design_vars = {k: v for k, v in zip('xy', optimal.T)}
design_vars['z'] = (optimal[:, 2], 0, 4)
xyz_problem = TopFarmProblem(design_vars,
cost_comp=DummyCost(optimal,
['x', 'y', 'z', 'type']),
constraints=[
SpacingConstraint(2),
XYBoundaryConstraint([(0, 0), (4, 4)],
'square')
],
driver=EasyScipyOptimizeDriver(disp=False))
initial_xyz_problem = TopFarmProblem(
design_vars={k: v
for k, v in zip('xyz', optimal.T)},
cost_comp=xyz_problem,
driver=DOEDriver(
ListGenerator([[('x', [0, 4]), ('y', [2, 2]), ('z', [4, 1])]])))
tf = TopFarmProblem({'type': ([0, 0], 0, 1)},
cost_comp=initial_xyz_problem,
driver=DOEDriver(FullFactorialGenerator(2)))
cost, _, recorder = tf.optimize()
best_index = np.argmin(recorder.get('cost'))
initial_xyz_recorder = recorder['recorder'][best_index]
xyz_recorder = initial_xyz_recorder.get('recorder')[0]
npt.assert_almost_equal(xyz_recorder['cost'][-1], cost)
def test_plackett_burman(self):
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = DOEDriver(PlackettBurmanGenerator())
prob.driver.add_recorder(SqliteRecorder("CASES.db"))
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
expected = {
0: {'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])},
1: {'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])},
2: {'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])},
3: {'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])},
}
cases = CaseReader("CASES.db").driver_cases
self.assertEqual(cases.num_cases, 4)
for n in range(cases.num_cases):
self.assertEqual(cases.get_case(n).outputs['x'], expected[n]['x'])
self.assertEqual(cases.get_case(n).outputs['y'], expected[n]['y'])
self.assertEqual(cases.get_case(n).outputs['f_xy'], expected[n]['f_xy'])
def test_uniform(self):
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*'])
model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*'])
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.add_design_var('x', lower=-10, upper=10)
model.add_design_var('y', lower=-10, upper=10)
model.add_objective('f_xy')
prob.driver = DOEDriver(UniformGenerator(num_samples=5, seed=0))
prob.driver.add_recorder(SqliteRecorder("CASES.db"))
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
# all values should be between -10 and 10, check expected values for seed = 0
expected = {
0: {'x': np.array([ 0.97627008]), 'y': np.array([ 4.30378733])},
1: {'x': np.array([ 2.05526752]), 'y': np.array([ 0.89766366])},
2: {'x': np.array([-1.52690401]), 'y': np.array([ 2.91788226])},
3: {'x': np.array([-1.24825577]), 'y': np.array([ 7.83546002])},
4: {'x': np.array([ 9.27325521]), 'y': np.array([-2.33116962])},
}
cases = CaseReader("CASES.db").driver_cases
self.assertEqual(cases.num_cases, 5)
for n in range(cases.num_cases):
assert_rel_error(self, cases.get_case(n).outputs['x'], expected[n]['x'], 1e-4)
assert_rel_error(self, cases.get_case(n).outputs['y'], expected[n]['y'], 1e-4)
def test_uniform(self):
from openmdao.api import Problem, IndepVarComp
from openmdao.test_suite.components.paraboloid import Paraboloid
from openmdao.api import DOEDriver, UniformGenerator, SqliteRecorder, CaseReader
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*'])
model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*'])
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.add_design_var('x', lower=-10, upper=10)
model.add_design_var('y', lower=-10, upper=10)
model.add_objective('f_xy')
prob.driver = DOEDriver(UniformGenerator(num_samples=5))
prob.driver.add_recorder(SqliteRecorder("CASES.db"))
prob.setup()
prob.run_driver()
prob.cleanup()
cases = CaseReader("CASES.db").driver_cases
self.assertEqual(cases.num_cases, 5)
values = []
for n in range(cases.num_cases):
case = cases.get_case(n)
values.append((case.outputs['x'], case.outputs['y'], case.outputs['f_xy']))
def test_doe(self):
filename = 'pyxdsm_doe'
out_format = PYXDSM_OUT
prob = Problem(model=Group())
indeps = prob.model.add_subsystem('indeps',
IndepVarComp(),
promotes=['*'])
indeps.add_output('x')
prob.model.add_subsystem('C1',
ExecComp(['y=2.0*x+1.'], x=2.0),
promotes=['*'])
prob.driver = DOEDriver()
prob.model.add_design_var('x', lower=0.0, upper=10.0)
prob.model.add_objective('y')
prob.setup(check=False)
# Conclude setup but don't run model.
prob.final_setup()
write_xdsm(prob,
filename=filename,
out_format=out_format,
quiet=QUIET,
show_browser=SHOW,
show_parallel=True)
# Check if file was created
self.assertTrue(os.path.isfile('.'.join([filename, out_format])))
def test_design_var_list(turbineTypeOptimizationProblem, design_vars):
tf = TopFarmProblem(design_vars=design_vars,
cost_comp=DummyCost(np.array([[2, 0, 1]]).T, ['type']),
driver=DOEDriver(FullFactorialGenerator(3)))
cost, _, = tf.evaluate()
npt.assert_equal(tf.cost, cost)
assert tf.cost == 5
def turbineTypeOptimizationProblem():
return TurbineTypeOptimizationProblem(
TurbineTypeDummyCost([2, 0, 1]),
turbineTypes=[0, 0, 0],
lower=[0, 0, 0],
upper=[2, 2, 2],
driver=DOEDriver(FullFactorialGenerator(3)))
def test_generator_check(self):
prob = Problem()
with self.assertRaises(TypeError) as err:
prob.driver = DOEDriver(FullFactorialGenerator)
self.assertEqual(str(err.exception),
"DOEDriver requires an instance of DOEGenerator, "
"but a class object was found: FullFactorialGenerator")
with self.assertRaises(TypeError) as err:
prob.driver = DOEDriver(Problem())
self.assertEqual(str(err.exception),
"DOEDriver requires an instance of DOEGenerator, "
"but an instance of Problem was found.")
def test_full_factorial_array(self):
prob = Problem()
model = prob.model
model.add_subsystem('p1',
IndepVarComp('xy', np.array([0., 0.])),
promotes=['*'])
model.add_subsystem('comp', ParaboloidArray(), promotes=['*'])
model.add_design_var('xy',
lower=np.array([-50., -50.]),
upper=np.array([50., 50.]))
model.add_objective('f_xy')
prob.driver = DOEDriver(FullFactorialGenerator(levels=3))
prob.driver.add_recorder(SqliteRecorder("cases.sql"))
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
expected = {
0: {
'xy': np.array([-50., -50.])
},
1: {
'xy': np.array([0., -50.])
},
2: {
'xy': np.array([50., -50.])
},
3: {
'xy': np.array([-50., 0.])
},
4: {
'xy': np.array([0., 0.])
},
5: {
'xy': np.array([50., 0.])
},
6: {
'xy': np.array([-50., 50.])
},
7: {
'xy': np.array([0., 50.])
},
8: {
'xy': np.array([50., 50.])
},
}
cases = CaseReader("cases.sql").driver_cases
self.assertEqual(cases.num_cases, 9)
for n in range(cases.num_cases):
outputs = cases.get_case(n).outputs
self.assertEqual(outputs['xy'][0], expected[n]['xy'][0])
self.assertEqual(outputs['xy'][1], expected[n]['xy'][1])
def test_full_factorial(self):
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = DOEDriver(FullFactorialGenerator(levels=3), parallel=True)
prob.driver.add_recorder(SqliteRecorder("CASES.db"))
prob.setup()
failed, output = run_driver(prob)
self.assertFalse(failed)
prob.cleanup()
expected = {
0: {'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])},
1: {'x': np.array([.5]), 'y': np.array([0.]), 'f_xy': np.array([19.25])},
2: {'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])},
3: {'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])},
4: {'x': np.array([.5]), 'y': np.array([.5]), 'f_xy': np.array([23.75])},
5: {'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])},
6: {'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])},
7: {'x': np.array([.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])},
8: {'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])},
}
size = prob.comm.size
rank = prob.comm.rank
# cases will be split across files for each proc
filename = "CASES.db_%d" % rank
expect_msg = "Cases from rank %d are being written to %s." % (rank, filename)
self.assertTrue(expect_msg in output)
cases = CaseReader(filename).driver_cases
# cases recorded on this proc
num_cases = cases.num_cases
self.assertEqual(num_cases, len(expected)//size+(rank<len(expected)%size))
for n in range(num_cases):
case = cases.get_case(n)
idx = n * size + rank # index of expected case
self.assertEqual(cases.get_case(n).outputs['x'], expected[idx]['x'])
self.assertEqual(cases.get_case(n).outputs['y'], expected[idx]['y'])
self.assertEqual(cases.get_case(n).outputs['f_xy'], expected[idx]['f_xy'])
def test_box_behnken(self):
upper = 10.
center = 1
prob = Problem()
model = prob.model
indep = model.add_subsystem('indep', IndepVarComp(), promotes=['*'])
indep.add_output('x', 0.0)
indep.add_output('y', 0.0)
indep.add_output('z', 0.0)
model.add_subsystem('comp', ExecComp('a = x**2 + y - z'), promotes=['*'])
model.add_design_var('x', lower=0., upper=upper)
model.add_design_var('y', lower=0., upper=upper)
model.add_design_var('z', lower=0., upper=upper)
model.add_objective('a')
prob.driver = DOEDriver(BoxBehnkenGenerator(center=center))
prob.driver.add_recorder(SqliteRecorder("CASES.db"))
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
cases = CaseReader("CASES.db").driver_cases
# The Box-Behnken design for 3 factors involves three blocks, in each of
# which 2 factors are varied thru the 4 possible combinations of high & low.
# It also includes centre points (all factors at their central values).
# ref: https://en.wikipedia.org/wiki/Box-Behnken_design
self.assertEqual(cases.num_cases, (3*4)+center)
expected = {
0: {'x': np.array([ 0.]), 'y': np.array([ 0.]), 'z': np.array([ 5.])},
1: {'x': np.array([10.]), 'y': np.array([ 0.]), 'z': np.array([ 5.])},
2: {'x': np.array([ 0.]), 'y': np.array([10.]), 'z': np.array([ 5.])},
3: {'x': np.array([10.]), 'y': np.array([10.]), 'z': np.array([ 5.])},
4: {'x': np.array([ 0.]), 'y': np.array([ 5.]), 'z': np.array([ 0.])},
5: {'x': np.array([10.]), 'y': np.array([ 5.]), 'z': np.array([ 0.])},
6: {'x': np.array([ 0.]), 'y': np.array([ 5.]), 'z': np.array([10.])},
7: {'x': np.array([10.]), 'y': np.array([ 5.]), 'z': np.array([10.])},
8: {'x': np.array([ 5.]), 'y': np.array([ 0.]), 'z': np.array([ 0.])},
9: {'x': np.array([ 5.]), 'y': np.array([10.]), 'z': np.array([ 0.])},
10: {'x': np.array([ 5.]), 'y': np.array([ 0.]), 'z': np.array([10.])},
11: {'x': np.array([ 5.]), 'y': np.array([10.]), 'z': np.array([10.])},
12: {'x': np.array([ 5.]), 'y': np.array([ 5.]), 'z': np.array([ 5.])},
}
for n in range(cases.num_cases):
self.assertEqual(cases.get_case(n).outputs['x'], expected[n]['x'])
self.assertEqual(cases.get_case(n).outputs['y'], expected[n]['y'])
self.assertEqual(cases.get_case(n).outputs['z'], expected[n]['z'])
def test_turbineType_optimization():
optimal = np.array([[1], [0]])
tf = TopFarmProblem(design_vars={'type': (optimal[:, 0], 0, 1)},
cost_comp=DummyCost(optimal_state=optimal,
inputs=['type']),
driver=DOEDriver(FullFactorialGenerator(2)))
cost, state, _ = tf.optimize()
assert cost == 0
npt.assert_array_equal(state['type'], [1, 0])
def test_latin_hypercube_center(self):
samples = 4
upper = 10.
prob = Problem()
model = prob.model
indep = model.add_subsystem('indep', IndepVarComp())
indep.add_output('x', 0.0)
indep.add_output('y', 0.0)
model.add_subsystem('comp', Paraboloid())
model.connect('indep.x', 'comp.x')
model.connect('indep.y', 'comp.y')
model.add_design_var('indep.x', lower=0., upper=upper)
model.add_design_var('indep.y', lower=0., upper=upper)
model.add_objective('comp.f_xy')
prob.driver = DOEDriver(LatinHypercubeGenerator(samples=samples, criterion='c'))
prob.driver.add_recorder(SqliteRecorder("CASES.db"))
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
cases = CaseReader("CASES.db").driver_cases
self.assertEqual(cases.num_cases, samples)
# the sample space for each variable (0 to upper) should be divided into
# equal size buckets and each variable should have a value in each bucket
bucket_size = upper/samples
all_buckets = set(range(samples))
x_buckets_filled = set()
y_buckets_filled = set()
# with criterion of 'center', each value should be in the center of it's bucket
valid_values = [round(bucket_size*(bucket + 1/2), 3) for bucket in all_buckets]
for n in range(cases.num_cases):
x = float(cases.get_case(n).outputs['indep.x'])
y = float(cases.get_case(n).outputs['indep.y'])
x_buckets_filled.add(int(x/bucket_size))
y_buckets_filled.add(int(y/bucket_size))
self.assertTrue(round(x, 3) in valid_values, '%f not in %s' % (x, valid_values))
self.assertTrue(round(y, 3) in valid_values, '%f not in %s' % (y, valid_values))
self.assertEqual(x_buckets_filled, all_buckets)
self.assertEqual(y_buckets_filled, all_buckets)
def test_turbineType_optimization():
cost_comp = DummyCost(optimal_state=optimal, inputs=['type'])
tf = TurbineTypeOptimizationProblem(cost_comp=cost_comp,
turbineTypes=[0, 0],
lower=0,
upper=1,
driver=DOEDriver(
FullFactorialGenerator(2)))
cost, state, _ = tf.optimize()
assert cost == 0
npt.assert_array_equal(state['type'], [1, 0])
def test_with_uniform_generator(get_tf):
tf = get_tf(driver=DOEDriver(UniformGenerator(10)))
arr = tf.get_DOE_array()
uta.assertGreaterEqual(arr[:, 0].min(), 10) # x
uta.assertLessEqual(arr[:, 0].max(), 11) # x
uta.assertGreaterEqual(arr[:, 1].min(), 6) # y
uta.assertLessEqual(arr[:, 1].max(), 8) # y
uta.assertGreaterEqual(arr[:, 2].min(), 3) # z
uta.assertLessEqual(arr[:, 2].max(), 4) # z
cost, _, recorder = tf.optimize()
npt.assert_equal(cost, np.min(recorder.get('cost')))
def test_list_driver(get_tf):
xyz = [[[1, 2], [3, 4], [5, 6]], [[4, 3], [6, 5], [2, 1]]]
lst = [[('x', [1, 2]), ('y', [3, 4]), ('z', [5, 6])],
[('x', [4, 3]), ('y', [6, 5]), ('z', [2, 1])]]
tf = get_tf(driver=lst) # pure list
npt.assert_array_equal(tf.get_DOE_array(), xyz)
tf = get_tf(driver=ListGenerator(lst)) # list generator
npt.assert_array_equal(tf.get_DOE_array(), xyz)
tf = get_tf(driver=DOEDriver(ListGenerator(lst))) # DOEDriver
npt.assert_array_equal(tf.get_DOE_array(), xyz)
def test_ListRecorder():
from openmdao.api import Problem, IndepVarComp
from openmdao.test_suite.components.paraboloid import Paraboloid
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*'])
model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*'])
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.add_design_var('x', lower=-10, upper=10)
model.add_design_var('y', lower=-10, upper=10)
model.add_objective('f_xy')
xyf = [[0.98, 4.30, 74.1844],
[2.06, 0.90, 23.7476],
[-1.53, 2.92, 60.9397],
[-1.25, 7.84, 145.4481]]
prob.driver = DOEDriver(ListGenerator([[('x', xy[0]), ('y', xy[1])] for xy in xyf]))
recorder = TopFarmListRecorder()
recorder._initialize_database()
recorder._cleanup_abs2meta()
recorder.record_iteration_problem(None, None, None)
recorder.record_iteration_system(None, None, None)
recorder.record_iteration_solver(None, None, None)
recorder.record_viewer_data(None)
recorder.record_metadata_solver(None)
recorder.record_derivatives_driver(None, None, None)
recorder.shutdown()
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['includes'] = ['*']
prob.driver.recording_options['record_inputs'] = True
prob.setup()
prob.run_driver()
prob.cleanup()
assert recorder.num_cases == 4
npt.assert_array_equal(recorder.get('counter'), range(1, 5))
npt.assert_array_equal(recorder['counter'], range(1, 5))
npt.assert_array_almost_equal(recorder.get(['x', 'y', 'f_xy']), xyf, 4)
for xyf, k in zip(xyf[0], ['x', 'y', 'f_xy']):
npt.assert_allclose(recorder[k][0], xyf)
with pytest.raises(KeyError, match="missing"):
recorder.get('missing')
def test_full_factorial(self):
from openmdao.api import Problem, IndepVarComp
from openmdao.test_suite.components.paraboloid import Paraboloid
from openmdao.api import DOEDriver, FullFactorialGenerator
from openmdao.api import SqliteRecorder, CaseReader
from mpi4py import MPI
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = DOEDriver(FullFactorialGenerator(levels=3))
prob.driver.options['parallel'] = True
prob.driver.add_recorder(SqliteRecorder("cases.sql"))
prob.setup()
prob.run_driver()
prob.cleanup()
self.assertEqual(MPI.COMM_WORLD.size, 2)
# check recorded cases from each case file
rank = MPI.COMM_WORLD.rank
filename = "cases.sql_%d" % rank
self.assertEqual(filename, "cases.sql_%d" % rank)
cases = CaseReader(filename).driver_cases
self.assertEqual(cases.num_cases, 5 if rank == 0 else 4)
values = []
for n in range(cases.num_cases):
outputs = cases.get_case(n).outputs
values.append((outputs['x'], outputs['y'], outputs['f_xy']))
self.assertEqual(
"\n" + "\n".join([
"x: %5.2f, y: %5.2f, f_xy: %6.2f" % (x, y, f_xy)
for x, y, f_xy in values
]), self.expect_text)
def test_indivisable_error(self):
prob = Problem()
prob.driver = DOEDriver(FullFactorialGenerator(levels=3))
prob.driver.options['parallel'] = 3
with self.assertRaises(RuntimeError) as context:
prob.setup()
self.assertEqual(
str(context.exception),
"The number of processors is not evenly divisable by the "
"specified number of parallel cases.\n Provide a number of "
"processors that is a multiple of 3, or specify a number "
"of parallel cases that divides into 4.")
def test_2level_turbineType_and_XYZ_optimization():
design_vars = {k: v for k, v in zip('xy', optimal.T)}
design_vars['z'] = (optimal[:, 2], 0, 4)
xyz_problem = TopFarmProblem(design_vars,
cost_comp=DummyCost(optimal,
['x', 'y', 'z', 'type']),
constraints=[
SpacingConstraint(2),
XYBoundaryConstraint([(0, 0), (4, 4)],
'square')
],
driver=EasyScipyOptimizeDriver(disp=False))
tf = TopFarmProblem({'type': ([0, 0], 0, 1)},
cost_comp=xyz_problem,
driver=DOEDriver(FullFactorialGenerator(2)))
cost = tf.optimize()[0]
assert cost == 0
def test_minprocs_error(self):
prob = Problem(FanInGrouped())
# require 2 procs for the ParallelGroup
prob.model._proc_info['sub'] = (2, None, 1.0)
# run cases on all procs
prob.driver = DOEDriver(FullFactorialGenerator(levels=3))
prob.driver.options['parallel'] = True
with self.assertRaises(RuntimeError) as context:
prob.setup()
self.assertEqual(
str(context.exception),
": MPI process allocation failed: can't meet min_procs "
"required for the following subsystems: ['sub']")
def test_fan_in_grouped(self):
from openmdao.api import Problem
from openmdao.test_suite.groups.parallel_groups import FanInGrouped
from openmdao.api import DOEDriver, FullFactorialGenerator
from openmdao.api import SqliteRecorder, CaseReader
from mpi4py import MPI
prob = Problem(FanInGrouped())
model = prob.model
model.add_design_var('iv.x1', lower=0.0, upper=1.0)
model.add_design_var('iv.x2', lower=0.0, upper=1.0)
model.add_objective('c3.y')
prob.driver = DOEDriver(FullFactorialGenerator(levels=3))
prob.driver.add_recorder(SqliteRecorder("cases.sql"))
# run 2 cases at a time, each using 2 of our 4 procs
doe_parallel = prob.driver.options['parallel'] = 2
prob.setup()
prob.run_driver()
prob.cleanup()
rank = MPI.COMM_WORLD.rank
# check recorded cases from each case file
if rank < doe_parallel:
filename = "cases.sql_%d" % rank
cases = CaseReader(filename).driver_cases
values = []
for n in range(cases.num_cases):
outputs = cases.get_case(n).outputs
values.append(
(outputs['iv.x1'], outputs['iv.x2'], outputs['c3.y']))
self.assertEqual(
"\n" + "\n".join([
"iv.x1: %5.2f, iv.x2: %5.2f, c3.y: %6.2f" % (x1, x2, y)
for x1, x2, y in values
]), self.expect_text)
def test_turbineType_and_XYZ_optimization():
plot_comp = DummyCostPlotComp(optimal)
plot_comp = NoPlot()
cost_comp = DummyCost(
optimal_state=optimal,
inputs=['x', 'y', 'z', 'type'])
xyz_opt_problem = TurbineXYZOptimizationProblem(
cost_comp,
turbineXYZ=[(0, 0, 0), (1, 1, 1)],
min_spacing=2,
boundary_comp=get_boundary_comp(),
plot_comp=plot_comp,
driver=EasyScipyOptimizeDriver(disp=False))
tf = TurbineTypeOptimizationProblem(
cost_comp=xyz_opt_problem,
turbineTypes=[0, 0], lower=0, upper=1,
driver=DOEDriver(FullFactorialGenerator(2)))
cost = tf.optimize()[0]
npt.assert_almost_equal(cost, 0)
def test_NestedTopFarmListRecorder(tf_generator):
optimal = [(0, 2, 4, 1), (4, 2, 1, 0)]
type_lst = [[0, 0], [1, 0], [0, 1]]
p1 = DummyCost(optimal_state=optimal, inputs=['x', 'y', 'z', 'type'])
p2 = tf_generator(cost_comp=p1, driver=EasyScipyOptimizeDriver(disp=False))
tf = TopFarmProblem({'type': ([0, 0], 0, 1)},
cost_comp=p2,
driver=DOEDriver(
ListGenerator([[('type', t)] for t in type_lst])))
cost, _, recorder = tf.optimize()
npt.assert_almost_equal(cost, 0)
npt.assert_array_almost_equal(recorder.get('type'), type_lst)
npt.assert_array_almost_equal(recorder.get('cost'), [1, 0, 2])
for sub_rec in recorder.get('recorder'):
npt.assert_array_almost_equal(
np.array([sub_rec[k][-1] for k in ['x', 'y', 'z']]).T,
np.array(optimal)[:, :3])
def test_full_factorial(self):
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.0), promotes=['x'])
model.add_subsystem('p2', IndepVarComp('y', 0.0), promotes=['y'])
model.add_subsystem('comp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
model.add_design_var('x', lower=0.0, upper=1.0)
model.add_design_var('y', lower=0.0, upper=1.0)
model.add_objective('f_xy')
prob.driver = DOEDriver(generator=FullFactorialGenerator(levels=3))
prob.driver.add_recorder(SqliteRecorder("CASES.db"))
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
expected = {
0: {'x': np.array([0.]), 'y': np.array([0.]), 'f_xy': np.array([22.00])},
1: {'x': np.array([.5]), 'y': np.array([0.]), 'f_xy': np.array([19.25])},
2: {'x': np.array([1.]), 'y': np.array([0.]), 'f_xy': np.array([17.00])},
3: {'x': np.array([0.]), 'y': np.array([.5]), 'f_xy': np.array([26.25])},
4: {'x': np.array([.5]), 'y': np.array([.5]), 'f_xy': np.array([23.75])},
5: {'x': np.array([1.]), 'y': np.array([.5]), 'f_xy': np.array([21.75])},
6: {'x': np.array([0.]), 'y': np.array([1.]), 'f_xy': np.array([31.00])},
7: {'x': np.array([.5]), 'y': np.array([1.]), 'f_xy': np.array([28.75])},
8: {'x': np.array([1.]), 'y': np.array([1.]), 'f_xy': np.array([27.00])},
}
cases = CaseReader("CASES.db").driver_cases
self.assertEqual(cases.num_cases, 9)
for n in range(cases.num_cases):
self.assertEqual(cases.get_case(n).outputs['x'], expected[n]['x'])
self.assertEqual(cases.get_case(n).outputs['y'], expected[n]['y'])
self.assertEqual(cases.get_case(n).outputs['f_xy'], expected[n]['f_xy'])
def test_no_generator(self):
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*'])
model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*'])
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.add_design_var('x', lower=-10, upper=10)
model.add_design_var('y', lower=-10, upper=10)
model.add_objective('f_xy')
prob.driver = DOEDriver()
prob.driver.add_recorder(SqliteRecorder("cases.sql"))
prob.setup(check=False)
prob.run_driver()
prob.cleanup()
cases = CaseReader("cases.sql").driver_cases
self.assertEqual(cases.num_cases, 0)
def test_ListRecorder():
from openmdao.api import Problem, IndepVarComp
from openmdao.test_suite.components.paraboloid import Paraboloid
prob = Problem()
model = prob.model
model.add_subsystem('p1', IndepVarComp('x', 0.), promotes=['*'])
model.add_subsystem('p2', IndepVarComp('y', 0.), promotes=['*'])
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.add_design_var('x', lower=-10, upper=10)
model.add_design_var('y', lower=-10, upper=10)
model.add_objective('f_xy')
xyf = [[0.98, 4.30, 74.1844], [2.06, 0.90, 23.7476],
[-1.53, 2.92, 60.9397], [-1.25, 7.84, 145.4481]]
prob.driver = DOEDriver(
ListGenerator([[('x', xy[0]), ('y', xy[1])] for xy in xyf]))
recorder = ListRecorder()
prob.driver.add_recorder(recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
cases = recorder.driver_cases
assert cases.num_cases == 4
npt.assert_array_equal(recorder.get('counter'), range(1, 5))
npt.assert_array_equal(recorder['counter'], range(1, 5))
npt.assert_array_almost_equal(recorder.get(['x', 'y', 'f_xy']), xyf, 4)
for xyf, k in zip(xyf[0], ['x', 'y', 'f_xy']):
npt.assert_allclose(cases.get_case(0).outputs[k][0], xyf)
with pytest.raises(KeyError, match="missing"):
recorder.get('missing')
def turbineTypeOptimizationProblem():
return TopFarmProblem(
design_vars={'type': ([0, 0, 0], 0, 2)},
cost_comp=DummyCost(np.array([[2, 0, 1]]).T, ['type']),
driver=DOEDriver(FullFactorialGenerator(3)))
def test_fan_in_grouped_serial(self):
# run cases on all procs (parallel model will run on single proc)
doe_parallel = True
prob = Problem(FanInGrouped())
model = prob.model
model.add_design_var('iv.x1', lower=0.0, upper=1.0)
model.add_design_var('iv.x2', lower=0.0, upper=1.0)
model.add_objective('c3.y')
prob.driver = DOEDriver(FullFactorialGenerator(levels=3))
prob.driver.add_recorder(SqliteRecorder("cases.sql"))
prob.driver.options['parallel'] = doe_parallel
prob.setup(check=False)
failed, output = run_driver(prob)
self.assertFalse(failed)
prob.cleanup()
expected = {
0: {
'iv.x1': np.array([0.]),
'iv.x2': np.array([0.]),
'c3.y': np.array([0.0])
},
1: {
'iv.x1': np.array([.5]),
'iv.x2': np.array([0.]),
'c3.y': np.array([-3.0])
},
2: {
'iv.x1': np.array([1.]),
'iv.x2': np.array([0.]),
'c3.y': np.array([-6.0])
},
3: {
'iv.x1': np.array([0.]),
'iv.x2': np.array([.5]),
'c3.y': np.array([17.5])
},
4: {
'iv.x1': np.array([.5]),
'iv.x2': np.array([.5]),
'c3.y': np.array([14.5])
},
5: {
'iv.x1': np.array([1.]),
'iv.x2': np.array([.5]),
'c3.y': np.array([11.5])
},
6: {
'iv.x1': np.array([0.]),
'iv.x2': np.array([1.]),
'c3.y': np.array([35.0])
},
7: {
'iv.x1': np.array([.5]),
'iv.x2': np.array([1.]),
'c3.y': np.array([32.0])
},
8: {
'iv.x1': np.array([1.]),
'iv.x2': np.array([1.]),
'c3.y': np.array([29.0])
},
}
rank = prob.comm.rank
size = prob.comm.size // doe_parallel
num_cases = 0
# cases will be split across files for each proc up to the number requested
filename = "cases.sql_%d" % rank
expect_msg = "Cases from rank %d are being written to %s." % (rank,
filename)
self.assertTrue(expect_msg in output)
cases = CaseReader(filename).driver_cases
# cases recorded on this proc
num_cases = cases.num_cases
self.assertEqual(num_cases,
len(expected) // size + (rank < len(expected) % size))
for n in range(num_cases):
idx = n * size + rank # index of expected case
outputs = cases.get_case(n).outputs
self.assertEqual(outputs['iv.x1'], expected[idx]['iv.x1'])
self.assertEqual(outputs['iv.x2'], expected[idx]['iv.x2'])
self.assertEqual(outputs['c3.y'], expected[idx]['c3.y'])
# total number of cases recorded across all requested procs
num_cases = prob.comm.allgather(num_cases)
self.assertEqual(sum(num_cases), len(expected))
