def test_with_promotion(self):
"""
Illustrative examples showing how to access variables and subjacs.
"""
c1 = IndepVarComp('x')
c2 = ExecComp('y=2*x')
c3 = ExecComp('z=3*x')
g = Group()
g.add_subsystem('c1', c1, promotes=['*'])
g.add_subsystem('c2', c2, promotes=['*'])
g.add_subsystem('c3', c3, promotes=['*'])
model = Group()
model.add_subsystem('g', g, promotes=['*'])
p = Problem(model)
p.setup()
# -------------------------------------------------------------------
# inputs
p['g.c2.x'] = 5.0
self.assertEqual(p['g.c2.x'], 5.0)
# outputs
p['g.c2.y'] = 5.0
self.assertEqual(p['g.c2.y'], 5.0)
p['y'] = 5.0
self.assertEqual(p['y'], 5.0)
# Conclude setup but don't run model.
p.final_setup()
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
inputs['c2.x'] = 5.0
self.assertEqual(inputs['c2.x'], 5.0)
# outputs
outputs['c2.y'] = 5.0
self.assertEqual(outputs['c2.y'], 5.0)
outputs['y'] = 5.0
self.assertEqual(outputs['y'], 5.0)
def test_with_promotion(self):
"""
Illustrative examples showing how to access variables and subjacs.
"""
c1 = IndepVarComp('x')
c2 = ExecComp('y=2*x')
c3 = ExecComp('z=3*x')
g = Group()
g.add_subsystem('c1', c1, promotes=['*'])
g.add_subsystem('c2', c2, promotes=['*'])
g.add_subsystem('c3', c3, promotes=['*'])
model = Group()
model.add_subsystem('g', g, promotes=['*'])
p = Problem(model)
p.setup(check=False)
# -------------------------------------------------------------------
# inputs
p['g.c2.x'] = 5.0
self.assertEqual(p['g.c2.x'], 5.0)
# outputs
p['g.c2.y'] = 5.0
self.assertEqual(p['g.c2.y'], 5.0)
p['y'] = 5.0
self.assertEqual(p['y'], 5.0)
# Conclude setup but don't run model.
p.final_setup()
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
inputs['c2.x'] = 5.0
self.assertEqual(inputs['c2.x'], 5.0)
# outputs
outputs['c2.y'] = 5.0
self.assertEqual(outputs['c2.y'], 5.0)
outputs['y'] = 5.0
self.assertEqual(outputs['y'], 5.0)
def test_no_promotion(self):
"""
Illustrative examples showing how to access variables and subjacs.
"""
c = ExecComp('y=2*x')
g = Group()
g.add_subsystem('c', c)
model = Group()
model.add_subsystem('g', g)
p = Problem(model)
p.setup()
# -------------------------------------------------------------------
# inputs
p['g.c.x'] = 5.0
self.assertEqual(p['g.c.x'], 5.0)
# outputs
p['g.c.y'] = 5.0
self.assertEqual(p['g.c.y'], 5.0)
# Conclude setup but don't run model.
p.final_setup()
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
inputs['c.x'] = 5.0
self.assertEqual(inputs['c.x'], 5.0)
# outputs
outputs['c.y'] = 5.0
self.assertEqual(outputs['c.y'], 5.0)
def test_no_promotion(self):
"""
Illustrative examples showing how to access variables and subjacs.
"""
c = ExecComp('y=2*x')
g = Group()
g.add_subsystem('c', c)
model = Group()
model.add_subsystem('g', g)
p = Problem(model)
p.setup(check=False)
# -------------------------------------------------------------------
# inputs
p['g.c.x'] = 5.0
self.assertEqual(p['g.c.x'], 5.0)
# outputs
p['g.c.y'] = 5.0
self.assertEqual(p['g.c.y'], 5.0)
# Conclude setup but don't run model.
p.final_setup()
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
inputs['c.x'] = 5.0
self.assertEqual(inputs['c.x'], 5.0)
# outputs
outputs['c.y'] = 5.0
self.assertEqual(outputs['c.y'], 5.0)
def test_vector_context_managers(self):
g1 = Group()
g1.add_subsystem('Indep', IndepVarComp('a', 5.0), promotes=['a'])
g2 = g1.add_subsystem('G2', Group(), promotes=['*'])
g2.add_subsystem('C1', ExecComp('b=2*a'), promotes=['a', 'b'])
model = Group()
model.add_subsystem('G1', g1, promotes=['b'])
model.add_subsystem('Sink', ExecComp('c=2*b'), promotes=['b'])
p = Problem(model=model)
p.set_solver_print(level=0)
# Test pre-setup errors
with self.assertRaises(Exception) as cm:
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(str(cm.exception),
"<class Group>: Cannot get vectors because setup has not yet been called.")
with self.assertRaises(Exception) as cm:
d_inputs, d_outputs, d_residuals = model.get_linear_vectors()
self.assertEqual(str(cm.exception),
"<class Group>: Cannot get vectors because setup has not yet been called.")
p.setup()
p.run_model()
# Test inputs with original values
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(inputs['G1.G2.C1.a'], 5.)
inputs, outputs, residuals = g1.get_nonlinear_vectors()
self.assertEqual(inputs['G2.C1.a'], 5.)
# Test inputs after setting a new value
inputs, outputs, residuals = g2.get_nonlinear_vectors()
inputs['C1.a'] = -1.
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(inputs['G1.G2.C1.a'], -1.)
inputs, outputs, residuals = g1.get_nonlinear_vectors()
self.assertEqual(inputs['G2.C1.a'], -1.)
# Test outputs with original values
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(outputs['G1.G2.C1.b'], 10.)
inputs, outputs, residuals = g2.get_nonlinear_vectors()
# Test outputs after setting a new value
inputs, outputs, residuals = model.get_nonlinear_vectors()
outputs['G1.G2.C1.b'] = 123.
self.assertEqual(outputs['G1.G2.C1.b'], 123.)
inputs, outputs, residuals = g2.get_nonlinear_vectors()
outputs['C1.b'] = 789.
self.assertEqual(outputs['C1.b'], 789.)
# Test residuals
inputs, outputs, residuals = model.get_nonlinear_vectors()
residuals['G1.G2.C1.b'] = 99.0
self.assertEqual(residuals['G1.G2.C1.b'], 99.0)
# Test linear
d_inputs, d_outputs, d_residuals = model.get_linear_vectors()
d_outputs['G1.G2.C1.b'] = 10.
self.assertEqual(d_outputs['G1.G2.C1.b'], 10.)
def test_no_promotion_errors(self):
"""
Tests for error-handling for invalid variable names and keys.
"""
g = Group(assembled_jac_type='dense')
g.linear_solver = DirectSolver(assemble_jac=True)
g.add_subsystem('c', ExecComp('y=2*x'))
p = Problem()
model = p.model
model.add_subsystem('g', g)
p.setup()
# -------------------------------------------------------------------
msg = 'Variable name "{}" not found.'
# inputs
with assertRaisesRegex(self, KeyError, msg.format('x')):
p['x'] = 5.0
p.final_setup()
p._initial_condition_cache = {}
with assertRaisesRegex(self, KeyError, msg.format('x')):
p['x']
# outputs
with assertRaisesRegex(self, KeyError, msg.format('y')):
p['y'] = 5.0
p.final_setup()
p._initial_condition_cache = {}
with assertRaisesRegex(self, KeyError, msg.format('y')):
p['y']
msg = 'Variable name "{}" not found.'
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
with assertRaisesRegex(self, KeyError, msg.format('x')):
inputs['x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('x')):
inputs['x']
with assertRaisesRegex(self, KeyError, msg.format('g.c.x')):
inputs['g.c.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.x')):
inputs['g.c.x']
# outputs
with assertRaisesRegex(self, KeyError, msg.format('y')):
outputs['y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y')):
outputs['y']
with assertRaisesRegex(self, KeyError, msg.format('g.c.y')):
outputs['g.c.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.y')):
outputs['g.c.y']
msg = r'Variable name pair \("{}", "{}"\) not found.'
jac = g.linear_solver._assembled_jac
# d(output)/d(input)
with assertRaisesRegex(self, KeyError, msg.format('y', 'x')):
jac['y', 'x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y', 'x')):
jac['y', 'x']
# allow absolute keys now
# with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.x')):
# jac['g.c.y', 'g.c.x'] = 5.0
# with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.x')):
# deriv = jac['g.c.y', 'g.c.x']
# d(output)/d(output)
with assertRaisesRegex(self, KeyError, msg.format('y', 'y')):
jac['y', 'y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y', 'y')):
jac['y', 'y']
def test_with_promotion_errors(self):
"""
Tests for error-handling for invalid variable names and keys.
"""
c1 = IndepVarComp('x')
c2 = ExecComp('y=2*x')
c3 = ExecComp('z=3*x')
g = Group(assembled_jac_type='dense')
g.add_subsystem('c1', c1, promotes=['*'])
g.add_subsystem('c2', c2, promotes=['*'])
g.add_subsystem('c3', c3, promotes=['*'])
g.linear_solver = DirectSolver(assemble_jac=True)
model = Group()
model.add_subsystem('g', g, promotes=['*'])
p = Problem(model)
p.setup()
# Conclude setup but don't run model.
p.final_setup()
# -------------------------------------------------------------------
msg1 = 'Variable name "{}" not found.'
msg2 = "The promoted name x is invalid because it refers to multiple inputs: " \
"[g.c2.x ,g.c3.x]. Access the value from the connected output variable x instead."
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
with self.assertRaises(Exception) as context:
inputs['x'] = 5.0
self.assertEqual(str(context.exception), msg2)
with self.assertRaises(Exception) as context:
self.assertEqual(inputs['x'], 5.0)
self.assertEqual(str(context.exception), msg2)
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.x')):
inputs['g.c2.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.x')):
self.assertEqual(inputs['g.c2.x'], 5.0)
# outputs
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y')):
outputs['g.c2.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y')):
self.assertEqual(outputs['g.c2.y'], 5.0)
msg1 = r'Variable name pair \("{}", "{}"\) not found.'
jac = g.linear_solver._assembled_jac
# d(outputs)/d(inputs)
with self.assertRaises(Exception) as context:
jac['y', 'x'] = 5.0
self.assertEqual(str(context.exception), msg2)
with self.assertRaises(Exception) as context:
self.assertEqual(jac['y', 'x'], 5.0)
self.assertEqual(str(context.exception), msg2)
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_no_promotion_errors(self):
"""
Tests for error-handling for invalid variable names and keys.
"""
g = Group(assembled_jac_type='dense')
g.linear_solver = DirectSolver(assemble_jac=True)
g.add_subsystem('c', ExecComp('y=2*x'))
p = Problem()
model = p.model
model.add_subsystem('g', g)
p.setup()
# -------------------------------------------------------------------
msg = '\'Group (<model>): Variable "{}" not found.\''
# inputs
with self.assertRaises(KeyError) as ctx:
p['x'] = 5.0
self.assertEqual(str(ctx.exception), msg.format('x'))
p._initial_condition_cache = {}
with self.assertRaises(KeyError) as ctx:
p['x']
self.assertEqual(str(ctx.exception), msg.format('x'))
# outputs
with self.assertRaises(KeyError) as ctx:
p['y'] = 5.0
self.assertEqual(str(ctx.exception), msg.format('y'))
p._initial_condition_cache = {}
with self.assertRaises(KeyError) as ctx:
p['y']
self.assertEqual(str(ctx.exception), msg.format('y'))
p.final_setup()
msg = "Group (g): Variable name '{}' not found."
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
for vname in ['x', 'g.c.x']:
with self.assertRaises(KeyError) as cm:
inputs[vname] = 5.0
self.assertEqual(cm.exception.args[0],
f"Group (g): Variable name '{vname}' not found.")
with self.assertRaises(KeyError) as cm:
inputs[vname]
self.assertEqual(cm.exception.args[0],
f"Group (g): Variable name '{vname}' not found.")
# outputs
for vname in ['y', 'g.c.y']:
with self.assertRaises(KeyError) as cm:
outputs[vname] = 5.0
self.assertEqual(cm.exception.args[0],
f"Group (g): Variable name '{vname}' not found.")
with self.assertRaises(KeyError) as cm:
outputs[vname]
self.assertEqual(cm.exception.args[0],
f"Group (g): Variable name '{vname}' not found.")
msg = r'Variable name pair \("{}", "{}"\) not found.'
jac = g.linear_solver._assembled_jac
# d(output)/d(input)
with self.assertRaisesRegex(KeyError, msg.format('y', 'x')):
jac['y', 'x'] = 5.0
with self.assertRaisesRegex(KeyError, msg.format('y', 'x')):
jac['y', 'x']
# allow absolute keys now
# with self.assertRaisesRegex(KeyError, msg.format('g.c.y', 'g.c.x')):
# jac['g.c.y', 'g.c.x'] = 5.0
# with self.assertRaisesRegex(KeyError, msg.format('g.c.y', 'g.c.x')):
# deriv = jac['g.c.y', 'g.c.x']
# d(output)/d(output)
with self.assertRaisesRegex(KeyError, msg.format('y', 'y')):
jac['y', 'y'] = 5.0
with self.assertRaisesRegex(KeyError, msg.format('y', 'y')):
jac['y', 'y']
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_with_promotion_errors(self):
"""
Tests for error-handling for invalid variable names and keys.
"""
c1 = IndepVarComp('x')
c2 = ExecComp('y=2*x')
c3 = ExecComp('z=3*x')
g = Group()
g.add_subsystem('c1', c1, promotes=['*'])
g.add_subsystem('c2', c2, promotes=['*'])
g.add_subsystem('c3', c3, promotes=['*'])
model = Group()
model.add_subsystem('g', g, promotes=['*'])
p = Problem(model)
p.setup(check=False)
# Conclude setup but don't run model.
p.final_setup()
# -------------------------------------------------------------------
msg1 = 'Variable name "{}" not found.'
msg2 = "The promoted name x is invalid because it refers to multiple inputs: [g.c2.x ,g.c3.x]. Access the value from the connected output variable x instead."
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
with self.assertRaises(Exception) as context:
inputs['x'] = 5.0
self.assertEqual(str(context.exception), msg2)
with self.assertRaises(Exception) as context:
self.assertEqual(inputs['x'], 5.0)
self.assertEqual(str(context.exception), msg2)
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.x')):
inputs['g.c2.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.x')):
self.assertEqual(inputs['g.c2.x'], 5.0)
# outputs
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y')):
outputs['g.c2.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y')):
self.assertEqual(outputs['g.c2.y'], 5.0)
msg1 = 'Variable name pair \("{}", "{}"\) not found.'
with g.jacobian_context() as jac:
# d(outputs)/d(inputs)
with self.assertRaises(Exception) as context:
jac['y', 'x'] = 5.0
self.assertEqual(str(context.exception), msg2)
with self.assertRaises(Exception) as context:
self.assertEqual(jac['y', 'x'], 5.0)
self.assertEqual(str(context.exception), msg2)
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y', 'g.c2.x')):
jac['g.c2.y', 'g.c2.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y', 'g.c2.x')):
self.assertEqual(jac['g.c2.y', 'g.c2.x'], 5.0)
# d(outputs)/d(outputs)
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y', 'g.c2.y')):
jac['g.c2.y', 'g.c2.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y', 'g.c2.y')):
self.assertEqual(jac['g.c2.y', 'g.c2.y'], 5.0)
def test_no_promotion_errors(self):
"""
Tests for error-handling for invalid variable names and keys.
"""
c = ExecComp('y=2*x')
g = Group()
g.add_subsystem('c', c)
model = Group()
model.add_subsystem('g', g)
p = Problem(model)
p.setup(check=False)
# -------------------------------------------------------------------
msg = 'Variable name "{}" not found.'
# inputs
with assertRaisesRegex(self, KeyError, msg.format('x')):
p['x'] = 5.0
p.final_setup()
p._initial_condition_cache = {}
with assertRaisesRegex(self, KeyError, msg.format('x')):
self.assertEqual(p['x'], 5.0)
# outputs
with assertRaisesRegex(self, KeyError, msg.format('y')):
p['y'] = 5.0
p.final_setup()
p._initial_condition_cache = {}
with assertRaisesRegex(self, KeyError, msg.format('y')):
self.assertEqual(p['y'], 5.0)
msg = 'Variable name "{}" not found.'
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
with assertRaisesRegex(self, KeyError, msg.format('x')):
inputs['x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('x')):
self.assertEqual(inputs['x'], 5.0)
with assertRaisesRegex(self, KeyError, msg.format('g.c.x')):
inputs['g.c.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.x')):
self.assertEqual(inputs['g.c.x'], 5.0)
# outputs
with assertRaisesRegex(self, KeyError, msg.format('y')):
outputs['y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y')):
self.assertEqual(outputs['y'], 5.0)
with assertRaisesRegex(self, KeyError, msg.format('g.c.y')):
outputs['g.c.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.y')):
self.assertEqual(outputs['g.c.y'], 5.0)
msg = 'Variable name pair \("{}", "{}"\) not found.'
with g.jacobian_context() as jac:
# d(output)/d(input)
with assertRaisesRegex(self, KeyError, msg.format('y', 'x')):
jac['y', 'x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y', 'x')):
self.assertEqual(jac['y', 'x'], 5.0)
with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.x')):
jac['g.c.y', 'g.c.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.x')):
self.assertEqual(jac['g.c.y', 'g.c.x'], 5.0)
# d(output)/d(output)
with assertRaisesRegex(self, KeyError, msg.format('y', 'y')):
jac['y', 'y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y', 'y')):
self.assertEqual(jac['y', 'y'], 5.0)
with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.y')):
jac['g.c.y', 'g.c.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.y')):
self.assertEqual(jac['g.c.y', 'g.c.y'], 5.0)
def test_with_promotion_errors(self):
"""
Tests for error-handling for invalid variable names and keys.
"""
c1 = IndepVarComp('x')
c2 = ExecComp('y=2*x')
c3 = ExecComp('z=3*x')
g = Group()
g.add_subsystem('c1', c1, promotes=['*'])
g.add_subsystem('c2', c2, promotes=['*'])
g.add_subsystem('c3', c3, promotes=['*'])
model = Group()
model.add_subsystem('g', g, promotes=['*'])
p = Problem(model)
p.setup(check=False)
# Conclude setup but don't run model.
p.final_setup()
# -------------------------------------------------------------------
msg1 = 'Variable name "{}" not found.'
msg2 = (
'The promoted name "{}" is invalid because it is non-unique. '
'Access the value from the connected output variable "{}" instead.'
)
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
with assertRaisesRegex(self, KeyError, msg2.format('x', 'x')):
inputs['x'] = 5.0
with assertRaisesRegex(self, KeyError, msg2.format('x', 'x')):
self.assertEqual(inputs['x'], 5.0)
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.x')):
inputs['g.c2.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.x')):
self.assertEqual(inputs['g.c2.x'], 5.0)
# outputs
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y')):
outputs['g.c2.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg1.format('g.c2.y')):
self.assertEqual(outputs['g.c2.y'], 5.0)
msg1 = 'Variable name pair \("{}", "{}"\) not found.'
with g.jacobian_context() as jac:
# d(outputs)/d(inputs)
with assertRaisesRegex(self, KeyError, msg2.format('x', 'x')):
jac['y', 'x'] = 5.0
with assertRaisesRegex(self, KeyError, msg2.format('x', 'x')):
self.assertEqual(jac['y', 'x'], 5.0)
with assertRaisesRegex(self, KeyError,
msg1.format('g.c2.y', 'g.c2.x')):
jac['g.c2.y', 'g.c2.x'] = 5.0
with assertRaisesRegex(self, KeyError,
msg1.format('g.c2.y', 'g.c2.x')):
self.assertEqual(jac['g.c2.y', 'g.c2.x'], 5.0)
# d(outputs)/d(outputs)
with assertRaisesRegex(self, KeyError,
msg1.format('g.c2.y', 'g.c2.y')):
jac['g.c2.y', 'g.c2.y'] = 5.0
with assertRaisesRegex(self, KeyError,
msg1.format('g.c2.y', 'g.c2.y')):
self.assertEqual(jac['g.c2.y', 'g.c2.y'], 5.0)
def test_vector_context_managers(self):
g1 = Group()
g1.add_subsystem('Indep', IndepVarComp('a', 5.0), promotes=['a'])
g2 = g1.add_subsystem('G2', Group(), promotes=['*'])
g2.add_subsystem('C1', ExecComp('b=2*a'), promotes=['a', 'b'])
model = Group()
model.add_subsystem('G1', g1, promotes=['b'])
model.add_subsystem('Sink', ExecComp('c=2*b'), promotes=['b'])
p = Problem(model=model)
p.set_solver_print(level=0)
# Test pre-setup errors
with self.assertRaises(Exception) as cm:
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(str(cm.exception),
"Cannot get vectors because setup has not yet been called.")
with self.assertRaises(Exception) as cm:
d_inputs, d_outputs, d_residuals = model.get_linear_vectors('vec')
self.assertEqual(str(cm.exception),
"Cannot get vectors because setup has not yet been called.")
p.setup()
p.run_model()
# Test inputs with original values
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(inputs['G1.G2.C1.a'], 5.)
inputs, outputs, residuals = g1.get_nonlinear_vectors()
self.assertEqual(inputs['G2.C1.a'], 5.)
# Test inputs after setting a new value
inputs, outputs, residuals = g2.get_nonlinear_vectors()
inputs['C1.a'] = -1.
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(inputs['G1.G2.C1.a'], -1.)
inputs, outputs, residuals = g1.get_nonlinear_vectors()
self.assertEqual(inputs['G2.C1.a'], -1.)
# Test outputs with original values
inputs, outputs, residuals = model.get_nonlinear_vectors()
self.assertEqual(outputs['G1.G2.C1.b'], 10.)
inputs, outputs, residuals = g2.get_nonlinear_vectors()
# Test outputs after setting a new value
inputs, outputs, residuals = model.get_nonlinear_vectors()
outputs['G1.G2.C1.b'] = 123.
self.assertEqual(outputs['G1.G2.C1.b'], 123.)
inputs, outputs, residuals = g2.get_nonlinear_vectors()
outputs['C1.b'] = 789.
self.assertEqual(outputs['C1.b'], 789.)
# Test residuals
inputs, outputs, residuals = model.get_nonlinear_vectors()
residuals['G1.G2.C1.b'] = 99.0
self.assertEqual(residuals['G1.G2.C1.b'], 99.0)
# Test linear
d_inputs, d_outputs, d_residuals = model.get_linear_vectors('linear')
d_outputs['G1.G2.C1.b'] = 10.
self.assertEqual(d_outputs['G1.G2.C1.b'], 10.)
# Test linear with invalid vec_name
with self.assertRaises(Exception) as cm:
d_inputs, d_outputs, d_residuals = model.get_linear_vectors('bad_name')
self.assertEqual(str(cm.exception),
"There is no linear vector named %s" % 'bad_name')
def test_no_promotion_errors(self):
"""
Tests for error-handling for invalid variable names and keys.
"""
g = Group(assembled_jac_type='dense')
g.linear_solver = DirectSolver(assemble_jac=True)
g.add_subsystem('c', ExecComp('y=2*x'))
p = Problem()
model = p.model
model.add_subsystem('g', g)
p.setup(check=False)
# -------------------------------------------------------------------
msg = 'Variable name "{}" not found.'
# inputs
with assertRaisesRegex(self, KeyError, msg.format('x')):
p['x'] = 5.0
p.final_setup()
p._initial_condition_cache = {}
with assertRaisesRegex(self, KeyError, msg.format('x')):
p['x']
# outputs
with assertRaisesRegex(self, KeyError, msg.format('y')):
p['y'] = 5.0
p.final_setup()
p._initial_condition_cache = {}
with assertRaisesRegex(self, KeyError, msg.format('y')):
p['y']
msg = 'Variable name "{}" not found.'
inputs, outputs, residuals = g.get_nonlinear_vectors()
# inputs
with assertRaisesRegex(self, KeyError, msg.format('x')):
inputs['x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('x')):
inputs['x']
with assertRaisesRegex(self, KeyError, msg.format('g.c.x')):
inputs['g.c.x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.x')):
inputs['g.c.x']
# outputs
with assertRaisesRegex(self, KeyError, msg.format('y')):
outputs['y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y')):
outputs['y']
with assertRaisesRegex(self, KeyError, msg.format('g.c.y')):
outputs['g.c.y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('g.c.y')):
outputs['g.c.y']
msg = r'Variable name pair \("{}", "{}"\) not found.'
jac = g.linear_solver._assembled_jac
# d(output)/d(input)
with assertRaisesRegex(self, KeyError, msg.format('y', 'x')):
jac['y', 'x'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y', 'x')):
jac['y', 'x']
# allow absolute keys now
# with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.x')):
# jac['g.c.y', 'g.c.x'] = 5.0
# with assertRaisesRegex(self, KeyError, msg.format('g.c.y', 'g.c.x')):
# deriv = jac['g.c.y', 'g.c.x']
# d(output)/d(output)
with assertRaisesRegex(self, KeyError, msg.format('y', 'y')):
jac['y', 'y'] = 5.0
with assertRaisesRegex(self, KeyError, msg.format('y', 'y')):
jac['y', 'y']
