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 initialize(self):
# type: () -> None
"""Method to initialize the problem by adding a recorder and doing the setup."""
self.driver.add_recorder(SqliteRecorder(self.case_reader_path))
self.driver.recording_options['includes'] = ['*']
if self._setup_status == 0:
self.setup()
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 setUp(self):
recording_iteration.stack = []
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.recorder = SqliteRecorder(self.filename)
# print(self.filename) # comment out to make filename printout go away.
self.eps = 1e-5
def setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.tablename = 'openmdao'
self.recorder = SqliteRecorder(self.filename)
self.recorder.options['record_metadata'] = False
self.eps = 1e-5
def setUp(self):
self.orig_dir = os.getcwd()
self.temp_dir = mkdtemp()
os.chdir(self.temp_dir)
self.filename = os.path.join(self.temp_dir, "sqlite_test")
self.recorder = SqliteRecorder(self.filename)
def _check_recorder_file(self, pb, cstr, filename):
pb.driver = OneraSegoDriver()
pb.driver.options["optimizer"] = "SEGOMOE"
pb.driver.opt_settings["maxiter"] = 10
# default model
n_var = 2
mod_obj = {
"type": "Krig",
"corr": "squared_exponential",
"regr": "constant",
"theta0": [1.0] * n_var,
"thetaL": [0.1] * n_var,
"thetaU": [10.0] * n_var,
"normalize": True,
}
model_type = {"obj": mod_obj}
if cstr:
model_type["con"] = mod_obj
pb.driver.opt_settings["model_type"] = model_type
recorder = SqliteRecorder(self.case_recorder_filename)
pb.model.add_recorder(recorder)
pb.setup()
self.pb.run_driver()
self.assertTrue(os.path.exists(self.case_recorder_filename))
reader = CaseReader(self.case_recorder_filename)
for case_id in reader.list_cases():
case = reader.get_case(case_id)
print(case.outputs["obj"])
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 setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.tablename_metadata = 'metadata'
self.tablename_iterations = 'iterations'
self.tablename_derivs = 'derivs'
self.recorder = SqliteRecorder(self.filename)
self.recorder.options['record_metadata'] = False
self.eps = 1e-5
def run_driver(name, driver):
pb = SellarProblem()
case_recorder_filename = "test_openturns_doe_{}.sqlite".format(name)
recorder = SqliteRecorder(case_recorder_filename)
pb.driver = driver
pb.driver.add_recorder(recorder)
pb.setup()
pb.run_driver()
pb.cleanup()
return pb, case_recorder_filename
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_recording(self):
# coloring involves an underlying call to run_model (and final_setup),
# this verifies that it is handled properly by the recording setup logic
recorder = SqliteRecorder('cases.sql')
p = run_opt(pyOptSparseDriver, 'auto', assemble_type='csc', optimizer='SNOPT',
dynamic_simul_derivs=True, print_results=False, recorder=recorder)
cr = CaseReader('cases.sql')
self.assertEqual(cr.list_cases(), ['rank0:SNOPT|%d' % i for i in range(p.driver.iter_count)])
def __init__(self, body, sc, method, nb_seg, order, solver, snopt_opts=None, rec_file=None):
"""Initializes NLP class. """
# input parameters
self.body = body
self.sc = sc
self.method = method
self.nb_seg = nb_seg
self.order = order
self.solver = solver
if self.solver == 'SNOPT':
self.snopt_opts = snopt_opts
else:
self.snopt_opts = None
self.rec_file = rec_file
# Problem object
self.p = Problem(model=Group())
# Problem Driver
self.p.driver = pyOptSparseDriver()
self.p.driver.options['optimizer'] = self.solver
self.p.driver.options['print_results'] = False
self.p.driver.options['dynamic_derivs_sparsity'] = True
if self.snopt_opts is not None:
for k in self.snopt_opts.keys():
self.p.driver.opt_settings[k] = self.snopt_opts[k]
self.p.driver.declare_coloring(show_summary=True, show_sparsity=False)
# Problem Recorder
if rec_file is not None:
recorder = SqliteRecorder(rec_file)
opts = ['record_objectives', 'record_constraints', 'record_desvars']
self.p.add_recorder(recorder)
for opt in opts:
self.p.recording_options[opt] = False
self.p.recording_options['excludes'] = rec_excludes
self.rec_file = rec_file
# Trajectory object
self.trajectory = self.p.model.add_subsystem('traj', Trajectory())
# Problem object for explicit simulation
self.p_exp = None
def assert_case_generation(self, n, driver):
pb = SellarProblem()
pb.driver = driver
case_recorder_filename = "test_smt_doe_driver_{}.sqlite".format(n)
recorder = SqliteRecorder(case_recorder_filename)
pb.driver.add_recorder(recorder)
pb.setup()
pb.run_driver()
pb.cleanup()
reader = CaseReader(case_recorder_filename)
cases = reader.list_cases("driver")
os.remove(case_recorder_filename)
self.assertEqual(len(cases), n)
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_beam_tutorial_viewmodel_using_data_from_sqlite_case_recorder_file(
self):
top = Problem()
top.root = BeamTutorial()
top.driver = ScipyOptimizer()
top.driver.options['optimizer'] = 'SLSQP'
top.driver.options['tol'] = 1.0e-8
top.driver.options[
'maxiter'] = 10000 #maximum number of solver iterations
top.driver.options['disp'] = False
#room length and width bounds
top.driver.add_desvar('ivc_rlength.room_length',
lower=5.0 * 12.0,
upper=50.0 *
12.0) #domain: 1in <= length <= 50ft
top.driver.add_desvar('ivc_rwidth.room_width',
lower=5.0 * 12.0,
upper=30.0 * 12.0) #domain: 1in <= width <= 30ft
top.driver.add_objective('d_neg_area.neg_room_area'
) #minimize negative area (or maximize area)
top.driver.add_constraint('d_len_minus_wid.length_minus_width',
lower=0.0) #room_length >= room_width
top.driver.add_constraint('d_deflection.deflection',
lower=720.0) #deflection >= 720
top.driver.add_constraint('d_bending.bending_stress_ratio',
upper=0.5) #bending < 0.5
top.driver.add_constraint('d_shear.shear_stress_ratio',
upper=1.0 / 3.0) #shear < 1/3
tempdir = mkdtemp()
case_recorder_filename = "tmp.sql"
filename = os.path.join(tempdir, case_recorder_filename)
recorder = SqliteRecorder(filename)
top.driver.add_recorder(recorder)
top.setup(check=False)
top.run()
view_model(filename, show_browser=False)
self.assertTrue(os.path.isfile('partition_tree_n2.html'))
os.remove('partition_tree_n2.html')
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_sellar(self):
self.pb = pb = Problem(SellarMDA())
pb.model.add_design_var("x", lower=0, upper=10)
pb.model.add_design_var("z", lower=0, upper=10)
pb.model.add_objective("obj")
pb.model.add_constraint("con1", upper=0)
pb.model.add_constraint("con2", upper=0)
pb.driver = OneraSegoDriver(optimizer="SEGOMOE")
pb.driver.opt_settings["maxiter"] = 10
self.case_recorder_filename = "test_segomoe_driver_sellar.sqlite"
recorder = SqliteRecorder(self.case_recorder_filename)
pb.model.add_recorder(recorder)
pb.setup()
self.pb.run_driver()
self.assertTrue(os.path.exists(self.case_recorder_filename))
reader = CaseReader(self.case_recorder_filename)
for case_id in reader.list_cases():
case = reader.get_case(case_id)
print(case.outputs["obj"])
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 run(self):
"""
Method to actually run analysis or optimization. Also saves history in
a .db file and creates an N2 diagram to view the problem hierarchy.
"""
# Uncomment this to use finite differences over the entire model
# self.prob.root.deriv_options['type'] = 'cs'
# Record optimization history to a database
# Data saved here can be examined using `plot_all.py`
recorder = SqliteRecorder(self.prob_dict['prob_name'] + ".db")
recorder.options['record_params'] = True
recorder.options['record_derivs'] = True
self.prob.driver.add_recorder(recorder)
# Profile (time) the problem
# profile.setup(self.prob)
# profile.start()
# Set up the problem
self.prob.setup()
# Uncomment this line to have more verbose output about convergence
# self.prob.print_all_convergence()
# Save an N2 diagram for the problem
view_model(self.prob,
outfile=self.prob_dict['prob_name'] + ".html",
show_browser=False)
# Run a single analysis loop to populate uninitialized values
self.prob.run_once()
# If `optimize` == True in prob_dict, perform optimization. Otherwise,
# simply pass the problem since analysis has already been run.
if not self.prob_dict['optimize']: # run analysis once
pass
else: # perform optimization
self.prob.run()
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 run_optimization(data_dir, problem_constants):
prob = Problem()
prob.model = SpiralStaircase(constants=problem_constants)
prob.model.add_recorder(
SqliteRecorder(recording_filename(data_dir, problem_constants.id)))
# This saves us some space and probably also time when loading the recording.
prob.model.recording_options["record_residuals"] = False
prob.model.recording_options["record_metadata"] = False
prob.model.recording_options["record_model_metadata"] = False
prob.driver = SimpleGADriver(
penalty_exponent=2.0,
penalty_parameter=1000.0,
max_gen=75,
pop_size=0, # Automatic
bits={
"design_vars.floor_height":
2,
"design_vars.floor_angle_clearance_scale_factor":
3,
"design_vars.floor_angle_clearance_placement_factor":
3,
"design_vars._orientation_index":
1,
"design_vars._radius_index":
int(np.ceil(np.log2(len(problem_constants.radii)))) or 1,
"design_vars.extra_sweep_tendency":
2,
"design_vars.extra_steps_tendency":
3,
},
multi_obj_weights={
"price_availability.total_price": 1 / 200_000,
"price_availability.total_delivery_time": 1 / 30,
"usability.usability_penalty": 25 * 1,
},
)
def test(self):
import numpy as np
from openaerostruct.geometry.utils import generate_mesh
from openaerostruct.geometry.geometry_group import Geometry
from openaerostruct.transfer.displacement_transfer import DisplacementTransfer
from openaerostruct.structures.struct_groups import SpatialBeamAlone
from openmdao.api import IndepVarComp, Problem, Group, SqliteRecorder
# Create a dictionary to store options about the surface
mesh_dict = {
'num_y': 7,
'wing_type': 'CRM',
'symmetry': True,
'num_twist_cp': 5
}
mesh, twist_cp = generate_mesh(mesh_dict)
surf_dict = {
# Wing definition
'name': 'wing', # name of the surface
'type': 'structural',
'symmetry': True, # if true, model one half of wing
# reflected across the plane y = 0
'fem_model_type': 'tube',
'mesh': mesh,
'num_x': mesh.shape[0],
'num_y': mesh.shape[1],
# Structural values are based on aluminum 7075
'E': 70.e9, # [Pa] Young's modulus of the spar
'G': 30.e9, # [Pa] shear modulus of the spar
'yield':
500.e6 / 2.5, # [Pa] yield stress divided by 2.5 for limiting case
'mrho': 3.e3, # [kg/m^3] material density
'fem_origin': 0.35, # normalized chordwise location of the spar
't_over_c': 0.15, # maximum airfoil thickness
'thickness_cp': np.ones((3)) * .1,
'wing_weight_ratio': 2.,
'exact_failure_constraint': False,
}
# Create the problem and assign the model group
prob = Problem()
ny = surf_dict['num_y']
indep_var_comp = IndepVarComp()
indep_var_comp.add_output('loads',
val=np.ones((ny, 6)) * 2e5,
units='N')
indep_var_comp.add_output('load_factor', val=1.)
struct_group = SpatialBeamAlone(surface=surf_dict)
# Add indep_vars to the structural group
struct_group.add_subsystem('indep_vars',
indep_var_comp,
promotes=['*'])
prob.model.add_subsystem(surf_dict['name'], struct_group)
from openmdao.api import ScipyOptimizeDriver
prob.driver = ScipyOptimizeDriver()
prob.driver.options['disp'] = True
recorder = SqliteRecorder('struct.db')
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_derivatives'] = True
# Setup problem and add design variables, constraint, and objective
prob.model.add_design_var('wing.thickness_cp',
lower=0.01,
upper=0.5,
scaler=1e2)
prob.model.add_constraint('wing.failure', upper=0.)
prob.model.add_constraint('wing.thickness_intersects', upper=0.)
# Add design variables, constraisnt, and objective on the problem
prob.model.add_objective('wing.structural_weight', scaler=1e-5)
# Set up the problem
prob.setup()
prob.run_driver()
assert_rel_error(self, prob['wing.structural_weight'][0],
697377.8734430908, 1e-8)
