def test_record_line_search_armijo_goldstein(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
model = self.prob.model
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyKrylov()
model._nonlinear_solver.options['solve_subsystems'] = True
model._nonlinear_solver.options['max_sub_solves'] = 4
ls = model._nonlinear_solver.linesearch = ArmijoGoldsteinLS(bound_enforcement='vector')
# This is pretty bogus, but it ensures that we get a few LS iterations.
ls.options['c'] = 100.0
ls.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
expected_abs_error = 3.49773898733e-9
expected_rel_error = expected_abs_error / 2.9086436370499857e-08
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(solver_iteration['abs_err'], expected_abs_error)
self.assertAlmostEqual(solver_iteration['rel_err'], expected_rel_error)
self.assertEqual(len(solver_iteration['solver_output']), 7)
self.assertEqual(solver_iteration['solver_residuals'], [])
def test_record_line_search_bounds_enforce(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
model = self.prob.model
model.nonlinear_solver = NewtonSolver()
model.linear_solver = ScipyKrylov()
model.nonlinear_solver.options['solve_subsystems'] = True
model.nonlinear_solver.options['max_sub_solves'] = 4
ls = model.nonlinear_solver.linesearch = BoundsEnforceLS(bound_enforcement='vector')
ls.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
expected_abs_error = 7.02783609310096e-10
expected_rel_error = 8.078674883382422e-07
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(solver_iteration['abs_err'], expected_abs_error)
self.assertAlmostEqual(solver_iteration['rel_err'], expected_rel_error)
self.assertEqual(len(solver_iteration['solver_output']), 7)
self.assertEqual(solver_iteration['solver_residuals'], [])
def test_only_desvars_recorded(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.driver.recording_options['record_desvars'] = True
self.prob.driver.recording_options['record_responses'] = False
self.prob.driver.recording_options['record_objectives'] = False
self.prob.driver.recording_options['record_constraints'] = False
self.prob.driver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
driver_iteration_data = json.loads(self.driver_iteration_data)
self.driver_iteration_data = None
self.assertTrue({'name': 'px.x', 'values': [1.0]} in driver_iteration_data['desvars'])
self.assertTrue({'name': 'pz.z', 'values': [5.0, 2.0]} in driver_iteration_data['desvars'])
self.assertEqual(driver_iteration_data['responses'], [])
self.assertEqual(driver_iteration_data['objectives'], [])
self.assertEqual(driver_iteration_data['constraints'], [])
def test_record_solver_nonlinear_nonlinear_run_once(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NonlinearRunOnce()
self.prob.model.nonlinear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
# No norms so no expected norms
expected_abs_error = 0.0
expected_rel_error = 0.0
expected_solver_residuals = None
expected_solver_output = None
solver_iteration = json.loads(self.solver_iterations)
self.assertEqual(expected_abs_error, solver_iteration['abs_err'])
self.assertEqual(expected_rel_error, solver_iteration['rel_err'])
self.assertEqual(solver_iteration['solver_residuals'], [])
self.assertEqual(len(solver_iteration['solver_output']), 7)
def test_only_objectives_recorded(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.driver.recording_options['record_desvars'] = False
self.prob.driver.recording_options['record_responses'] = False
self.prob.driver.recording_options['record_objectives'] = True
self.prob.driver.recording_options['record_constraints'] = False
self.prob.driver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
driver_iteration_data = json.loads(self.driver_iteration_data)
self.assertAlmostEqual(
driver_iteration_data['objectives'][0]['values'][0], 28.5883082)
self.assertEqual(driver_iteration_data['objectives'][0]['name'],
'obj_cmp.obj')
self.assertEqual(driver_iteration_data['desvars'], [])
self.assertEqual(driver_iteration_data['responses'], [])
self.assertEqual(driver_iteration_data['constraints'], [])
def test_record_solver_linear_scipy_iterative_solver(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NewtonSolver()
# used for analytic derivatives
self.prob.model.nonlinear_solver.linear_solver = ScipyKrylov()
linear_solver = self.prob.model.nonlinear_solver.linear_solver
linear_solver.recording_options['record_abs_error'] = True
linear_solver.recording_options['record_rel_error'] = True
linear_solver.recording_options['record_solver_residuals'] = True
self.prob.model.nonlinear_solver.linear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
expected_abs_error = 0.0
expected_rel_error = 0.0
expected_solver_output = [
{'name': 'px.x', 'values': [0.0]},
{'name': 'pz.z', 'values': [0.0, 0.0]},
]
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(0.0, solver_iteration['abs_err'])
self.assertAlmostEqual(0.0, solver_iteration['rel_err'])
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
def test_sysincludes_recorded_with_excludes(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.driver.recording_options['record_desvars'] = False
self.prob.driver.recording_options['record_responses'] = False
self.prob.driver.recording_options['record_objectives'] = False
self.prob.driver.recording_options['record_constraints'] = False
self.prob.driver.recording_options['includes'] = ['*']
self.prob.driver.recording_options['excludes'] = ['obj_cmp.obj']
self.prob.driver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
driver_iteration_data = json.loads(self.driver_iteration_data)
self.assertEqual(len(driver_iteration_data['sysincludes']), 2)
self.assertEqual(len(driver_iteration_data['objectives']), 0)
self.assertEqual(len(driver_iteration_data['desvars']), 0)
self.assertEqual(len(driver_iteration_data['constraints']), 0)
self.assertEqual(len(driver_iteration_data['responses']), 0)
def test_distrib_record_driver(self):
# create distributed variables of different sizes to catch mismatched collective calls
sizes = [7, 10, 12, 25, 33, 42]
prob = om.Problem()
ivc = prob.model.add_subsystem('ivc',
om.IndepVarComp(),
promotes_outputs=['*'])
for n, size in enumerate(sizes):
ivc.add_output(f'in{n}', np.ones(size), distributed=True)
prob.model.add_design_var(f'in{n}')
prob.model.add_subsystem('adder',
DistributedAdder(sizes),
promotes=['*'])
prob.model.add_subsystem('summer',
Summer(sizes),
promotes_outputs=['sum'])
for n, size in enumerate(sizes):
prob.model.promotes('summer',
inputs=[f'summand{n}'],
src_indices=om.slicer[:],
src_shape=size)
prob.model.add_objective('sum')
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['includes'] = [
f'out{n}' for n in range(len(sizes))
]
prob.driver.add_recorder(self.recorder)
prob.setup()
t0, t1 = run_driver(prob)
prob.cleanup()
coordinate = [0, 'Driver', (0, )]
expected_desvars = {}
for n in range(len(sizes)):
expected_desvars[f'ivc.in{n}'] = prob.get_val(f'ivc.in{n}',
get_remote=True)
expected_objectives = {"summer.sum": prob['summer.sum']}
expected_outputs = expected_desvars.copy()
for n in range(len(sizes)):
expected_outputs[f'adder.out{n}'] = prob.get_val(f'adder.out{n}',
get_remote=True)
if prob.comm.rank == 0:
expected_outputs.update(expected_objectives)
expected_data = ((coordinate, (t0, t1), expected_outputs, None,
None), )
assertDriverIterDataRecorded(self, expected_data, self.eps)
def test_record_solver_linear_linear_run_once(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
# raise unittest.SkipTest("Linear Solver recording not working yet")
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NewtonSolver()
# used for analytic derivatives
self.prob.model.nonlinear_solver.linear_solver = LinearRunOnce()
linear_solver = self.prob.model.nonlinear_solver.linear_solver
linear_solver.recording_options['record_abs_error'] = True
linear_solver.recording_options['record_rel_error'] = True
linear_solver.recording_options['record_solver_residuals'] = True
self.prob.model.nonlinear_solver.linear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
solver_iteration = json.loads(self.solver_iterations)
expected_abs_error = 0.0
expected_rel_error = 0.0
expected_solver_output = [
{
'name': 'px.x',
'values': [0.0]
},
{
'name': 'pz.z',
'values': [0.0, 0.0]
},
{
'name': 'd1.y1',
'values': [-4.15366975e-05]
},
{
'name': 'd2.y2',
'values': [-4.10568454e-06]
},
{
'name': 'obj_cmp.obj',
'values': [-4.15366737e-05]
},
{
'name': 'con_cmp1.con1',
'values': [4.15366975e-05]
},
{
'name': 'con_cmp2.con2',
'values': [-4.10568454e-06]
},
]
self.assertAlmostEqual(expected_abs_error, solver_iteration['abs_err'])
self.assertAlmostEqual(expected_rel_error, solver_iteration['rel_err'])
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
def test_simple_driver_recording(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
prob = Problem()
model = prob.model = Group()
model.add_subsystem('p1', IndepVarComp('x', 50.0), promotes=['*'])
model.add_subsystem('p2', IndepVarComp('y', 50.0), promotes=['*'])
model.add_subsystem('comp', Paraboloid(), promotes=['*'])
model.add_subsystem('con', ExecComp('c = - x + y'), promotes=['*'])
model.suppress_solver_output = True
prob.driver = pyOptSparseDriver()
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_responses'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.options['optimizer'] = OPTIMIZER
if OPTIMIZER == 'SLSQP':
prob.driver.opt_settings['ACC'] = 1e-9
model.add_design_var('x', lower=-50.0, upper=50.0)
model.add_design_var('y', lower=-50.0, upper=50.0)
model.add_objective('f_xy')
model.add_constraint('c', upper=-15.0)
prob.setup(check=False)
t0, t1 = run_driver(prob)
prob.cleanup()
driver_iteration_data = json.loads(self.driver_iteration_data)
expected_desvars = [
{'name': 'p1.x', 'values': [7.1666666]},
{'name': 'p2.y', 'values': [-7.8333333]}
]
expected_objectives = [
{'name': 'comp.f_xy', 'values': [-27.083333]}
]
expected_constraints = [
{'name': 'con.c', 'values': [-15.0]}
]
for d in expected_desvars:
self.assert_array_close(d, driver_iteration_data['desvars'])
for o in expected_objectives:
self.assert_array_close(o, driver_iteration_data['objectives'])
for c in expected_constraints:
self.assert_array_close(c, driver_iteration_data['constraints'])
def test_record_solver_linear_block_gs(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NewtonSolver()
# used for analytic derivatives
self.prob.model.nonlinear_solver.linear_solver = LinearBlockGS()
linear_solver = self.prob.model.nonlinear_solver.linear_solver
linear_solver.recording_options['record_abs_error'] = True
linear_solver.recording_options['record_rel_error'] = True
linear_solver.recording_options['record_solver_residuals'] = True
self.prob.model.nonlinear_solver.linear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
solver_iteration = json.loads(self.solver_iterations)
expected_abs_error = 9.109083208861876e-11
expected_rel_error = 9.114367543620551e-12
expected_solver_output = [
{
'name': 'px.x',
'values': [0.0]
},
{
'name': 'pz.z',
'values': [0.0, 0.0]
},
{
'name': 'd1.y1',
'values': [0.00045069]
},
{
'name': 'd2.y2',
'values': [-0.00225346]
},
{
'name': 'obj_cmp.obj',
'values': [0.00045646]
},
{
'name': 'con_cmp1.con1',
'values': [-0.00045069]
},
{
'name': 'con_cmp2.con2',
'values': [-0.00225346]
},
]
self.assertAlmostEqual(expected_abs_error, solver_iteration['abs_err'])
self.assertAlmostEqual(expected_rel_error, solver_iteration['rel_err'])
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
def test_record_solver_linear_block_jac(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NewtonSolver()
# used for analytic derivatives
self.prob.model.nonlinear_solver.linear_solver = LinearBlockJac()
linear_solver = self.prob.model.nonlinear_solver.linear_solver
linear_solver.recording_options['record_abs_error'] = True
linear_solver.recording_options['record_rel_error'] = True
linear_solver.recording_options['record_solver_residuals'] = True
self.prob.model.nonlinear_solver.linear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
solver_iteration = json.loads(self.solver_iterations)
expected_abs_error = 9.947388408259769e-11
expected_rel_error = 4.330301334141486e-08
expected_solver_output = [
{
'name': 'px.x',
'values': [0.0]
},
{
'name': 'pz.z',
'values': [0.0, 0.0]
},
{
'name': 'd1.y1',
'values': [4.55485639e-09]
},
{
'name': 'd2.y2',
'values': [-2.27783334e-08]
},
{
'name': 'obj_cmp.obj',
'values': [-2.28447051e-07]
},
{
'name': 'con_cmp1.con1',
'values': [2.28461863e-07]
},
{
'name': 'con_cmp2.con2',
'values': [-2.27742837e-08]
},
]
self.assertAlmostEqual(expected_abs_error, solver_iteration['abs_err'])
self.assertAlmostEqual(expected_rel_error, solver_iteration['rel_err'])
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
def test_implicit_component(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
from openmdao.core.tests.test_impl_comp import QuadraticLinearize, QuadraticJacVec
group = Group()
group.add_subsystem('comp1',
IndepVarComp([('a', 1.0), ('b', 1.0), ('c', 1.0)]))
group.add_subsystem('comp2', QuadraticLinearize())
group.add_subsystem('comp3', QuadraticJacVec())
group.connect('comp1.a', 'comp2.a')
group.connect('comp1.b', 'comp2.b')
group.connect('comp1.c', 'comp2.c')
group.connect('comp1.a', 'comp3.a')
group.connect('comp1.b', 'comp3.b')
group.connect('comp1.c', 'comp3.c')
prob = Problem(model=group)
prob.setup(check=False)
prob['comp1.a'] = 1.
prob['comp1.b'] = -4.
prob['comp1.c'] = 3.
comp2 = prob.model.comp2 # ImplicitComponent
comp2.add_recorder(recorder)
t0, t1 = run_driver(prob)
prob.cleanup()
expected_inputs = [{
'name': 'comp2.a',
'values': [1.0]
}, {
'name': 'comp2.b',
'values': [-4.0]
}, {
'name': 'comp2.c',
'values': [3.0]
}]
expected_outputs = [{'name': 'comp2.x', 'values': [3.0]}]
expected_residuals = [{'name': 'comp2.x', 'values': [0.0]}]
system_iteration = json.loads(self.system_iterations)
for i in expected_inputs:
self.assert_array_close(i, system_iteration['inputs'])
for r in expected_residuals:
self.assert_array_close(r, system_iteration['residuals'])
for o in expected_outputs:
self.assert_array_close(o, system_iteration['outputs'])
def test_record_solver_nonlinear_block_gs(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NonlinearBlockGS()
self.prob.model.nonlinear_solver.add_recorder(recorder)
nonlinear_solver = self.prob.model.nonlinear_solver
nonlinear_solver.recording_options['record_solver_residuals'] = True
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
coordinate = [0, 'Driver', (0,), 'root._solve_nonlinear', (0,), 'NonlinearBlockGS', (6, )]
expected_abs_error = 1.31880284470753394998e-10
expected_rel_error = 3.6299074030587596e-12
expected_solver_output = [
{'name': 'px.x', 'values': [1.0]},
{'name': 'pz.z', 'values': [5., 2.]},
{'name': 'd1.y1', 'values': [25.58830237]},
{'name': 'd2.y2', 'values': [12.05848815]},
{'name': 'obj_cmp.obj', 'values': [28.58830817]},
{'name': 'con_cmp1.con1', 'values': [-22.42830237]},
{'name': 'con_cmp2.con2', 'values': [-11.94151185]}
]
expected_solver_residuals = [
{'name': 'px.x', 'values': [-0]},
{'name': 'pz.z', 'values': [-0., -0.]},
{'name': 'd1.y1', 'values': [1.31880284e-10]},
{'name': 'd2.y2', 'values': [0.]},
{'name': 'obj_cmp.obj', 'values': [0.]},
{'name': 'con_cmp1.con1', 'values': [0.]},
{'name': 'con_cmp2.con2', 'values': [0.]},
]
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(solver_iteration['abs_err'], expected_abs_error)
self.assertAlmostEqual(solver_iteration['rel_err'], expected_rel_error)
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
for r in expected_solver_residuals:
self.assert_array_close(r, solver_iteration['solver_residuals'])
def test_only_constraints_recorded(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.driver.recording_options['record_desvars'] = False
self.prob.driver.recording_options['record_responses'] = False
self.prob.driver.recording_options['record_objectives'] = False
self.prob.driver.recording_options['record_constraints'] = True
self.prob.driver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
driver_iteration_data = json.loads(self.driver_iteration_data)
if driver_iteration_data['constraints'][0]['name'] == 'con_cmp1.con1':
self.assertAlmostEqual(
driver_iteration_data['constraints'][0]['values'][0],
-22.42830237)
self.assertAlmostEqual(
driver_iteration_data['constraints'][1]['values'][0],
-11.94151185)
self.assertEqual(driver_iteration_data['constraints'][1]['name'],
'con_cmp2.con2')
self.assertEqual(driver_iteration_data['constraints'][0]['name'],
'con_cmp1.con1')
elif driver_iteration_data['constraints'][0][
'name'] == 'con_cmp2.con2':
self.assertAlmostEqual(
driver_iteration_data['constraints'][1]['values'][0],
-22.42830237)
self.assertAlmostEqual(
driver_iteration_data['constraints'][0]['values'][0],
-11.94151185)
self.assertEqual(driver_iteration_data['constraints'][0]['name'],
'con_cmp2.con2')
self.assertEqual(driver_iteration_data['constraints'][1]['name'],
'con_cmp1.con1')
else:
self.assertTrue(
False, 'Driver iteration data did not contain\
the expected names for constraints')
self.assertEqual(driver_iteration_data['desvars'], [])
self.assertEqual(driver_iteration_data['objectives'], [])
self.assertEqual(driver_iteration_data['responses'], [])
def test_distrib_record_driver(self):
size = 100 # how many items in the array
prob = Problem()
prob.model.add_subsystem('des_vars',
IndepVarComp('x', np.ones(size)),
promotes=['x'])
prob.model.add_subsystem('plus',
DistributedAdder(size),
promotes=['x', 'y'])
prob.model.add_subsystem('summer',
Summer(size),
promotes_outputs=['sum'])
prob.model.promotes('summer', inputs=['y'], src_indices=slicer[:])
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['includes'] = ['y']
prob.driver.add_recorder(self.recorder)
prob.model.add_design_var('x')
prob.model.add_objective('sum')
prob.setup()
prob['x'] = np.ones(size)
t0, t1 = run_driver(prob)
prob.cleanup()
coordinate = [0, 'Driver', (0, )]
expected_desvars = {
"des_vars.x": prob['des_vars.x'],
}
expected_objectives = {
"summer.sum": prob['summer.sum'],
}
expected_outputs = expected_desvars.copy()
expected_outputs['plus.y'] = prob.get_val('plus.y', get_remote=True)
if prob.comm.rank == 0:
expected_outputs.update(expected_objectives)
expected_data = ((coordinate, (t0, t1), expected_outputs, None,
None), )
assertDriverIterDataRecorded(self, expected_data, self.eps)
def test_record_solver(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
nonlinear_solver = self.prob.model._nonlinear_solver
nonlinear_solver.recording_options['record_abs_error'] = True
nonlinear_solver.recording_options['record_rel_error'] = True
nonlinear_solver.recording_options['record_solver_residuals'] = True
self.prob.model._nonlinear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
expected_solver_output = [
{'name': 'con_cmp1.con1', 'values': [-22.42830237000701]},
{'name': 'd1.y1', 'values': [25.58830237000701]},
{'name': 'con_cmp2.con2', 'values': [-11.941511849375644]},
{'name': 'pz.z', 'values': [5.0, 2.0]},
{'name': 'obj_cmp.obj', 'values': [28.588308165163074]},
{'name': 'd2.y2', 'values': [12.058488150624356]},
{'name': 'px.x', 'values': [1.0]}
]
expected_solver_residuals = [
{'name': 'con_cmp1.con1', 'values': [0.0]},
{'name': 'd1.y1', 'values': [1.318802844707534e-10]},
{'name': 'con_cmp2.con2', 'values': [0.0]},
{'name': 'pz.z', 'values': [0.0, 0.0]},
{'name': 'obj_cmp.obj', 'values': [0.0]},
{'name': 'd2.y2', 'values': [0.0]},
{'name': 'px.x', 'values': [0.0]}
]
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(solver_iteration['abs_err'], 1.31880284470753394998e-10)
self.assertAlmostEqual(solver_iteration['rel_err'], 3.6299074030587596e-12)
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
for r in expected_solver_residuals:
self.assert_array_close(r, solver_iteration['solver_residuals'])
def test_record_solver_linear_direct_solver(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NewtonSolver()
# used for analytic derivatives
self.prob.model.nonlinear_solver.linear_solver = DirectSolver()
linear_solver = self.prob.model.nonlinear_solver.linear_solver
linear_solver.recording_options['record_abs_error'] = True
linear_solver.recording_options['record_rel_error'] = True
linear_solver.recording_options['record_solver_residuals'] = True
self.prob.model.nonlinear_solver.linear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
expected_solver_output = [
{'name': 'px.x', 'values': [0.0]},
{'name': 'pz.z', 'values': [0.0, 0.0]},
{'name': 'd1.y1', 'values': [0.00045069]},
{'name': 'd2.y2', 'values': [-0.00225346]},
{'name': 'obj_cmp.obj', 'values': [0.00045646]},
{'name': 'con_cmp1.con1', 'values': [-0.00045069]},
{'name': 'con_cmp2.con2', 'values': [-0.00225346]},
]
expected_solver_residuals = [
{'name': 'px.x', 'values': [0.0]},
{'name': 'pz.z', 'values': [-0., -0.]},
{'name': 'd1.y1', 'values': [0.0]},
{'name': 'd2.y2', 'values': [-0.00229801]},
{'name': 'obj_cmp.obj', 'values': [5.75455956e-06]},
{'name': 'con_cmp1.con1', 'values': [-0.]},
{'name': 'con_cmp2.con2', 'values': [-0.]},
]
solver_iteration = json.loads(self.solver_iterations)
self.assertAlmostEqual(0.0, solver_iteration['abs_err'])
self.assertAlmostEqual(0.0, solver_iteration['rel_err'])
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
for r in expected_solver_residuals:
self.assert_array_close(r, solver_iteration['solver_residuals'])
def test_driver_everything_recorded_by_default(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.driver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
driver_iteration_data = json.loads(self.driver_iteration_data)
self.assertEqual(len(driver_iteration_data['sysincludes']), 2)
self.assertEqual(len(driver_iteration_data['objectives']), 1)
self.assertEqual(len(driver_iteration_data['desvars']), 2)
self.assertEqual(len(driver_iteration_data['constraints']), 2)
self.assertEqual(driver_iteration_data['responses'], [])
def test_distrib_record_driver(self):
size = 100 # how many items in the array
prob = Problem()
prob.model = Group()
prob.model.add_subsystem('des_vars',
IndepVarComp('x', np.ones(size)),
promotes=['x'])
prob.model.add_subsystem('plus',
DistributedAdder(size),
promotes=['x', 'y'])
prob.model.add_subsystem('summer', Summer(size), promotes=['y', 'sum'])
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_responses'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['includes'] = []
prob.driver.add_recorder(self.recorder)
prob.model.add_design_var('x')
prob.model.add_objective('sum')
prob.setup(vector_class=PETScVector, check=False)
prob['x'] = np.ones(size)
t0, t1 = run_driver(prob)
prob.cleanup()
if prob.comm.rank == 0:
coordinate = [0, 'Driver', (0, )]
expected_desvars = {
"des_vars.x": prob['des_vars.x'],
}
expected_objectives = {
"summer.sum": prob['summer.sum'],
}
self.assertDriverIterationDataRecorded(
((coordinate, (t0, t1), expected_desvars, None,
expected_objectives, None, None), ), self.eps)
def test_distrib_record_driver(self):
size = 100 # how many items in the array
prob = Problem()
prob.model = Group()
prob.model.add_subsystem('des_vars', IndepVarComp('x', np.ones(size)), promotes=['x'])
prob.model.add_subsystem('plus', DistributedAdder(size), promotes=['x', 'y'])
prob.model.add_subsystem('summer', Summer(size), promotes=['y', 'sum'])
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_responses'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['includes'] = []
prob.driver.add_recorder(self.recorder)
prob.model.add_design_var('x')
prob.model.add_objective('sum')
prob.setup(check=False)
prob['x'] = np.ones(size)
t0, t1 = run_driver(prob)
prob.cleanup()
if prob.comm.rank == 0:
coordinate = [0, 'Driver', (0,)]
expected_desvars = {
"des_vars.x": prob['des_vars.x'],
}
expected_objectives = {
"summer.sum": prob['summer.sum'],
}
expected_outputs = expected_desvars
expected_outputs.update(expected_objectives)
expected_data = ((coordinate, (t0, t1), expected_outputs, None),)
assertDriverIterDataRecorded(self, expected_data, self.eps)
def test_record_solver_nonlinear_newton(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NewtonSolver()
self.prob.model.nonlinear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
solver_iteration = json.loads(self.solver_iterations)
expected_abs_error = 2.1677810075550974e-10
expected_rel_error = 5.966657077752565e-12
self.assertAlmostEqual(expected_abs_error, solver_iteration['abs_err'])
self.assertAlmostEqual(expected_rel_error, solver_iteration['rel_err'])
self.assertEqual(solver_iteration['solver_residuals'], [])
self.assertEqual(len(solver_iteration['solver_output']), 7)
def test_record_solver_nonlinear_block_jac(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.nonlinear_solver = NonlinearBlockJac()
self.prob.model.nonlinear_solver.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
solver_iteration = json.loads(self.solver_iterations)
expected_abs_error = 7.234027587097439e-07
expected_rel_error = 1.991112651729199e-08
self.assertAlmostEqual(expected_abs_error, solver_iteration['abs_err'])
self.assertAlmostEqual(expected_rel_error, solver_iteration['rel_err'])
self.assertEqual(solver_iteration['solver_residuals'], [])
self.assertEqual(len(solver_iteration['solver_output']), 7)
def test_recording_remote_voi(self):
# Create a parallel model
model = Group()
model.add_subsystem('par', ParallelGroup())
model.par.add_subsystem('G1', Mygroup())
model.par.add_subsystem('G2', Mygroup())
model.connect('par.G1.y', 'Obj.y1')
model.connect('par.G2.y', 'Obj.y2')
model.add_subsystem('Obj', ExecComp('obj=y1+y2'))
model.add_objective('Obj.obj')
# Configure driver to record VOIs on both procs
driver = ScipyOptimizeDriver(disp=False)
driver.recording_options['record_desvars'] = True
driver.recording_options['record_responses'] = True
driver.recording_options['record_objectives'] = True
driver.recording_options['record_constraints'] = True
driver.recording_options['includes'] = ['par.G1.y', 'par.G2.y']
driver.add_recorder(self.recorder)
# Create problem and run driver
prob = Problem(model, driver)
prob.setup()
t0, t1 = run_driver(prob)
prob.cleanup()
# Since the test will compare the last case recorded, just check the
# current values in the problem. This next section is about getting those values
# These involve collective gathers so all ranks need to run this
expected_outputs = prob.driver.get_design_var_values()
expected_outputs.update(prob.driver.get_objective_values())
expected_outputs.update(prob.driver.get_constraint_values())
# includes for outputs are specified as promoted names but we need absolute names
prom2abs = model._var_allprocs_prom2abs_list['output']
abs_includes = [
prom2abs[n][0] for n in prob.driver.recording_options['includes']
]
# Absolute path names of includes on this rank
rrank = model.comm.rank
rowned = model._owning_rank
local_includes = [n for n in abs_includes if rrank == rowned[n]]
# Get values for all vars on this rank
inputs, outputs, residuals = model.get_nonlinear_vectors()
# Get values for includes on this rank
local_vars = {n: outputs[n] for n in local_includes}
# Gather values for includes on all ranks
all_vars = model.comm.gather(local_vars, root=0)
if prob.comm.rank == 0:
# Only on rank 0 do we have all the values. The all_vars variable is a list of
# dicts from all ranks 0,1,... In this case, just ranks 0 and 1
dct = all_vars[-1]
for d in all_vars[:-1]:
dct.update(d)
expected_includes = {
'par.G1.Cy.y': dct['par.G1.Cy.y'],
'par.G2.Cy.y': dct['par.G2.Cy.y'],
}
expected_outputs.update(expected_includes)
coordinate = [0, 'ScipyOptimize_SLSQP', (driver.iter_count - 1, )]
expected_data = ((coordinate, (t0, t1), expected_outputs, None), )
assertDriverIterDataRecorded(self, expected_data, self.eps)
def test_recording_remote_voi(self):
# Create a parallel model
model = Group()
model.add_subsystem('par', ParallelGroup())
model.par.add_subsystem('G1', Mygroup())
model.par.add_subsystem('G2', Mygroup())
model.connect('par.G1.y', 'Obj.y1')
model.connect('par.G2.y', 'Obj.y2')
model.add_subsystem('Obj', ExecComp('obj=y1+y2'))
model.add_objective('Obj.obj')
# Configure driver to record VOIs on both procs
driver = ScipyOptimizeDriver(disp=False)
driver.recording_options['record_desvars'] = True
driver.recording_options['record_responses'] = True
driver.recording_options['record_objectives'] = True
driver.recording_options['record_constraints'] = True
driver.recording_options['includes'] = ['par.G1.y', 'par.G2.y']
driver.add_recorder(self.recorder)
# Create problem and run driver
prob = Problem(model, driver)
prob.add_recorder(self.recorder)
prob.setup()
t0, t1 = run_driver(prob)
prob.record_iteration('final')
t2 = time()
prob.cleanup()
# Since the test will compare the last case recorded, just check the
# current values in the problem. This next section is about getting those values
# These involve collective gathers so all ranks need to run this
expected_outputs = driver.get_design_var_values()
expected_outputs.update(driver.get_objective_values())
expected_outputs.update(driver.get_constraint_values())
# includes for outputs are specified as promoted names but we need absolute names
prom2abs = model._var_allprocs_prom2abs_list['output']
abs_includes = [prom2abs[n][0] for n in prob.driver.recording_options['includes']]
# Absolute path names of includes on this rank
rrank = model.comm.rank
rowned = model._owning_rank
local_includes = [n for n in abs_includes if rrank == rowned[n]]
# Get values for all vars on this rank
inputs, outputs, residuals = model.get_nonlinear_vectors()
# Get values for includes on this rank
local_vars = {n: outputs[n] for n in local_includes}
# Gather values for includes on all ranks
all_vars = model.comm.gather(local_vars, root=0)
if prob.comm.rank == 0:
# Only on rank 0 do we have all the values. The all_vars variable is a list of
# dicts from all ranks 0,1,... In this case, just ranks 0 and 1
dct = all_vars[-1]
for d in all_vars[:-1]:
dct.update(d)
expected_includes = {
'par.G1.Cy.y': dct['par.G1.Cy.y'],
'par.G2.Cy.y': dct['par.G2.Cy.y'],
}
expected_outputs.update(expected_includes)
coordinate = [0, 'ScipyOptimize_SLSQP', (driver.iter_count-1,)]
expected_data = ((coordinate, (t0, t1), expected_outputs, None),)
assertDriverIterDataRecorded(self, expected_data, self.eps)
expected_data = (('final', (t1, t2), expected_outputs),)
assertProblemDataRecorded(self, expected_data, self.eps)
def test_recording_remote_voi(self):
prob = Problem()
prob.model.add_subsystem('par', ParallelGroup())
prob.model.par.add_subsystem('G1', Mygroup())
prob.model.par.add_subsystem('G2', Mygroup())
prob.model.add_subsystem('Obj', ExecComp('obj=y1+y2'))
prob.model.connect('par.G1.y', 'Obj.y1')
prob.model.connect('par.G2.y', 'Obj.y2')
prob.model.add_objective('Obj.obj')
prob.driver = pyOptSparseDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_responses'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['includes'] = ['par.G1.Cy.y','par.G2.Cy.y']
prob.driver.add_recorder(self.recorder)
prob.setup(vector_class=PETScVector)
t0, t1 = run_driver(prob)
prob.cleanup()
# Since the test will compare the last case recorded, just check the
# current values in the problem. This next section is about getting those values
# These involve collective gathers so all ranks need to run this
expected_desvars = prob.driver.get_design_var_values()
expected_objectives = prob.driver.get_objective_values()
expected_constraints = prob.driver.get_constraint_values()
# Determine the expected values for the sysincludes
# this gets all of the outputs but just locally
rrank = prob.comm.rank # root ( aka model ) rank.
rowned = prob.model._owning_rank['output']
# names of sysincl vars on this rank
local_inclnames = [n for n in prob.driver.recording_options['includes'] if rrank == rowned[n]]
# Get values for vars on this rank
inputs, outputs, residuals = prob.model.get_nonlinear_vectors()
# Potential local sysvars are in this
sysvars = outputs._names
# Just get the values for the sysincl vars on this rank
local_vars = {c: sysvars[c] for c in local_inclnames}
# Gather up the values for all the sysincl vars on all ranks
all_vars = prob.model.comm.gather(local_vars, root=0)
if prob.comm.rank == 0:
# Only on rank 0 do we have all the values and only on rank 0
# are we doing the testing.
# The all_vars variable is list of dicts from rank 0,1,... In this case just ranks 0 and 1
dct = all_vars[-1]
for d in all_vars[:-1]:
dct.update(d)
expected_includes = {
'par.G1.Cy.y': dct['par.G1.Cy.y'],
'par.G2.Cy.y': dct['par.G2.Cy.y'],
}
if prob.comm.rank == 0:
coordinate = [0, 'SLSQP', (49,)]
self.assertDriverIterationDataRecorded(((coordinate, (t0, t1), expected_desvars, None,
expected_objectives, expected_constraints,
expected_includes),), self.eps)
def test_recording_remote_voi(self):
prob = Problem()
prob.model.add_subsystem('par', ParallelGroup())
prob.model.par.add_subsystem('G1', Mygroup())
prob.model.par.add_subsystem('G2', Mygroup())
prob.model.add_subsystem('Obj', ExecComp('obj=y1+y2'))
prob.model.connect('par.G1.y', 'Obj.y1')
prob.model.connect('par.G2.y', 'Obj.y2')
prob.model.add_objective('Obj.obj')
prob.driver = pyOptSparseDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_responses'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['includes'] = [
'par.G1.Cy.y', 'par.G2.Cy.y'
]
prob.driver.add_recorder(self.recorder)
prob.setup()
t0, t1 = run_driver(prob)
prob.cleanup()
# Since the test will compare the last case recorded, just check the
# current values in the problem. This next section is about getting those values
# These involve collective gathers so all ranks need to run this
expected_outputs = prob.driver.get_design_var_values()
expected_outputs.update(prob.driver.get_objective_values())
expected_outputs.update(prob.driver.get_constraint_values())
# Determine the expected values for the sysincludes
# this gets all of the outputs but just locally
rrank = prob.comm.rank # root ( aka model ) rank.
rowned = prob.model._owning_rank
# names of sysincl vars on this rank
local_inclnames = [
n for n in prob.driver.recording_options['includes']
if rrank == rowned[n]
]
# Get values for vars on this rank
inputs, outputs, residuals = prob.model.get_nonlinear_vectors()
# Potential local sysvars are in this
sysvars = outputs._views
# Just get the values for the sysincl vars on this rank
local_vars = {c: sysvars[c] for c in local_inclnames}
# Gather up the values for all the sysincl vars on all ranks
all_vars = prob.model.comm.gather(local_vars, root=0)
if prob.comm.rank == 0:
# Only on rank 0 do we have all the values. The all_vars variable is a list of
# dicts from all ranks 0,1,... In this case, just ranks 0 and 1
dct = all_vars[-1]
for d in all_vars[:-1]:
dct.update(d)
expected_includes = {
'par.G1.Cy.y': dct['par.G1.Cy.y'],
'par.G2.Cy.y': dct['par.G2.Cy.y'],
}
expected_outputs.update(expected_includes)
coordinate = [0, 'SLSQP', (48, )]
expected_data = ((coordinate, (t0, t1), expected_outputs, None), )
assertDriverIterDataRecorded(self, expected_data, self.eps)
def test_record_driver_system_solver(self, m):
# Test what happens when all three types are recorded:
# Driver, System, and Solver
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_grouped_model()
self.prob.driver = pyOptSparseDriver()
self.prob.driver.options['optimizer'] = OPTIMIZER
self.prob.driver.opt_settings['ACC'] = 1e-9
# Add recorders
# Driver
self.prob.driver.recording_options['record_metadata'] = True
self.prob.driver.recording_options['record_desvars'] = True
self.prob.driver.recording_options['record_responses'] = True
self.prob.driver.recording_options['record_objectives'] = True
self.prob.driver.recording_options['record_constraints'] = True
self.prob.driver.add_recorder(recorder)
# System
pz = self.prob.model.pz # IndepVarComp which is an ExplicitComponent
pz.recording_options['record_metadata'] = True
pz.recording_options['record_inputs'] = True
pz.recording_options['record_outputs'] = True
pz.recording_options['record_residuals'] = True
pz.add_recorder(recorder)
# Solver
mda = self.prob.model.mda
mda.nonlinear_solver.recording_options['record_metadata'] = True
mda.nonlinear_solver.recording_options['record_abs_error'] = True
mda.nonlinear_solver.recording_options['record_rel_error'] = True
mda.nonlinear_solver.recording_options['record_solver_residuals'] = True
mda.nonlinear_solver.add_recorder(recorder)
self.prob.setup(check=False, mode='rev')
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
# Driver recording test
coordinate = [0, 'SLSQP', (7, )]
expected_desvars = [
{'name': 'pz.z', 'values': self.prob['pz.z']},
{'name': 'px.x', 'values': self.prob['px.x']}
]
expected_objectives = [
{'name': 'obj_cmp.obj', 'values': self.prob['obj_cmp.obj']}
]
expected_constraints = [
{'name': 'con_cmp1.con1', 'values': self.prob['con_cmp1.con1']},
{'name': 'con_cmp2.con2', 'values': self.prob['con_cmp2.con2']}
]
driver_iteration_data = json.loads(self.driver_iteration_data)
for d in expected_desvars:
self.assert_array_close(d, driver_iteration_data['desvars'])
for o in expected_objectives:
self.assert_array_close(o, driver_iteration_data['objectives'])
for c in expected_constraints:
self.assert_array_close(c, driver_iteration_data['constraints'])
# System recording test
expected_inputs = []
expected_outputs = [{'name': 'pz.z', 'values': [1.978467, -1.6464114e-13]}]
expected_residuals = [{'name': 'pz.z', 'values': [0.0, 0.0]}]
system_iteration = json.loads(self.system_iterations)
self.assertEqual(expected_inputs, system_iteration['inputs'])
for o in expected_outputs:
self.assert_array_close(o, system_iteration['outputs'])
for r in expected_residuals:
self.assert_array_close(r, system_iteration['residuals'])
# Solver recording test
expected_abs_error = 3.90598e-11
expected_rel_error = 2.0701941e-06
expected_solver_output = [
{'name': 'mda.d2.y2', 'values': [3.75610598]},
{'name': 'mda.d1.y1', 'values': [3.16]}
]
expected_solver_residuals = [
{'name': 'mda.d2.y2', 'values': [0.0]},
{'name': 'mda.d1.y1', 'values': [0.0]}
]
solver_iteration = json.loads(self.solver_iterations)
np.testing.assert_almost_equal(expected_abs_error, solver_iteration['abs_err'], decimal=5)
np.testing.assert_almost_equal(expected_rel_error, solver_iteration['rel_err'], decimal=5)
for o in expected_solver_output:
self.assert_array_close(o, solver_iteration['solver_output'])
for r in expected_solver_residuals:
self.assert_array_close(r, solver_iteration['solver_residuals'])
def test_record_system(self, m):
self.setup_endpoints(m)
recorder = WebRecorder(self._accepted_token, suppress_output=True)
self.setup_sellar_model()
self.prob.model.recording_options['record_inputs'] = True
self.prob.model.recording_options['record_outputs'] = True
self.prob.model.recording_options['record_residuals'] = True
self.prob.model.recording_options['record_metadata'] = True
self.prob.model.add_recorder(recorder)
d1 = self.prob.model.d1 # instance of SellarDis1withDerivatives, a Group
d1.add_recorder(recorder)
obj_cmp = self.prob.model.obj_cmp # an ExecComp
obj_cmp.add_recorder(recorder)
self.prob.setup(check=False)
t0, t1 = run_driver(self.prob)
self.prob.cleanup()
system_iterations = json.loads(self.system_iterations)
inputs = [
{'name': 'd1.z', 'values': [5.0, 2.0]},
{'name': 'd1.x', 'values': [1.0]},
{'name': 'd2.z', 'values': [5.0, 2.0]},
{'name': 'd1.y2', 'values': [12.05848815]}
]
outputs = [
{'name': 'd1.y1', 'values': [25.58830237]}
]
residuals = [
{'name': 'd1.y1', 'values': [0.0]}
]
for i in inputs:
self.assert_array_close(i, system_iterations['inputs'])
for o in outputs:
self.assert_array_close(o, system_iterations['outputs'])
for r in residuals:
self.assert_array_close(r, system_iterations['residuals'])
inputs = [
{'name': 'con_cmp2.y2', 'values': [12.058488150624356]},
{'name': 'obj_cmp.y1', 'values': [25.58830237000701]},
{'name': 'obj_cmp.x', 'values': [1.0]},
{'name': 'obj_cmp.z', 'values': [5.0, 2.0]}
]
outputs = [
{'name': 'obj_cmp.obj', 'values': [28.58830816]}
]
residuals = [
{'name': 'obj_cmp.obj', 'values': [0.0]}
]
for i in inputs:
self.assert_array_close(i, system_iterations['inputs'])
for o in outputs:
self.assert_array_close(o, system_iterations['outputs'])
for r in residuals:
self.assert_array_close(r, system_iterations['residuals'])
