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']