def test_opt1_a(self):
self.top.driver.add_objective('comp.result')
self.top.driver.add_parameter('comp.x', -10.0, 99.0)
self.top.driver.add_constraint('comp.g <= 0.')
self.top.driver.recorders = [ListCaseRecorder()]
self.top.driver.printvars = ['comp.opt_objective']
self.top.run()
self.assertAlmostEqual(self.top.comp.opt_objective,
self.top.driver.eval_objective(), places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[0],
self.top.comp.x[0], places=1)
self.assertAlmostEqual(self.top.comp.opt_design_vars[1],
self.top.comp.x[1], places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[2],
self.top.comp.x[2], places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[3],
self.top.comp.x[3], places=1)
cases = self.top.driver.recorders[0].get_iterator()
end_case = cases[-1]
self.assertEqual(self.top.comp.x[1],
end_case.get_input('comp.x')[1])
self.assertEqual(self.top.comp.opt_objective,
end_case.get_output('comp.opt_objective'))
def test_CSVCaseIterator_read_external_file_with_header(self):
# Without a label column
csv_data = ['"comp1.x", "comp1.y", "comp2.b_string"\n',
'33.5, 76.2, "Hello There"\n'
'3.14159, 0, "Goodbye z"\n'
]
outfile = open(self.filename, 'w')
outfile.writelines(csv_data)
outfile.close()
self.top.comp2.add('b_string', Str("Hello',;','", iotype='in'))
sout = StringIO.StringIO()
self.top.driver.iterator = CSVCaseIterator(filename=self.filename)
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.run()
self.assertEqual(self.top.comp1.x, 3.14159)
self.assertEqual(self.top.comp1.y, 0.0)
self.assertEqual(self.top.comp2.b_string, "Goodbye z")
# Gui pane stuff
attrs = self.top.driver.iterator.get_attributes()
self.assertTrue("Inputs" in attrs.keys())
self.assertTrue({'name': 'filename',
'type': 'str',
'connected': '',
'value': 'openmdao_test_csv_case_iterator.csv',
'desc': 'Name of the CSV file to be iterated.'} in attrs['Inputs'])
self.assertTrue({'name': 'headers',
'type': 'NoneType',
'connected': '',
'value': 'None',
'desc': 'Optional dictionary of header labels, where the key is the column number.'} in attrs['Inputs'])
# With a label column
csv_data = ['"label", "comp1.x", "comp1.y", "comp2.b_string"\n',
'"case1", 33.5, 76.2, "Hello There"\n'
]
outfile = open(self.filename, 'w')
outfile.writelines(csv_data)
outfile.close()
self.top.driver.iterator = CSVCaseIterator(filename=self.filename)
self.top.driver.recorders = [ListCaseRecorder()]
self.top.run()
it = self.top.driver.recorders[0].get_iterator()
case1 = it.pop()
self.assertEqual(case1.label, 'case1')
def run(self, input_dict, output_dict):
""" Performs finite difference of our submodel with respect to wrt.
Variables are intialized with init_vals.
input_dict: dict( string : value )
Dictionary of baseline values for input paramters
input_dict: dict( string : value )
Dictionary of baseline values for desired outputs
"""
# Set all initial values
for varname, value in input_dict.iteritems():
self.model.set(varname, value)
self.model.driver.recorders = [ListCaseRecorder()]
if self.model.driver.distribution_generator.form != 'CENTRAL':
self.model.driver.distribution_generator.skip_baseline = True
# Calculate finite differences.
# FFAD mode is supported.
self.model.driver.calc_derivatives(first=True)
self.model.run()
# Return all needed derivatives
cases = self.model.driver.recorders[0].cases
icase = 0
derivs = {}
for wrt, val in self.model.driver.get_parameters().iteritems():
derivs[wrt] = {}
if self.model.driver.distribution_generator.form == 'CENTRAL':
delx = cases[icase][wrt] - cases[icase + 1][wrt]
for out in self.model.driver.case_outputs:
derivs[wrt][out] = \
(cases[icase][out] - cases[icase+1][out])/delx
icase += 2
else:
delx = cases[icase][wrt] - input_dict[wrt]
for out in self.model.driver.case_outputs:
derivs[wrt][out] = \
(cases[icase][out] - output_dict[out])/delx
icase += 1
return derivs
def configure(self):
self.add('paraboloid', Paraboloid())
self.add('driver', COBYLAdriver())
self.driver.add_parameter('paraboloid.x', low=-50, high=50)
self.driver.add_parameter('paraboloid.y', low=-50, high=50)
self.driver.add_objective('paraboloid.f_xy')
self.recorders = [ListCaseRecorder()]
def test_output_errors(self):
inputs = [('driven.x', numpy_random.normal(size=4)),
('driven.y', numpy_random.normal(size=10)),
('driven.raise_error', False), ('driven.stop_exec', False)]
outputs = ['driven.rosen_suzuki', 'driven.foobar']
self.cases = [Case(inputs, outputs, label='1')]
self.model.driver.sequential = True
self.model.driver.iterator = ListCaseIterator(self.cases)
self.model.driver.recorders = [ListCaseRecorder()]
self.model.driver.printvars = ['driven.extra']
self.model.driver.error_policy = 'RETRY'
self.model.run()
def configure(self):
self.add('paraboloid', Paraboloid())
self.add('driver', DOEdriver())
self.driver.DOEgenerator = Uniform(1000)
self.driver.add_parameter('paraboloid.x', low=-50, high=50)
self.driver.add_parameter('paraboloid.y', low=-50, high=50)
self.driver.add_response('paraboloid.f_xy')
self.recorders = [ListCaseRecorder()]
def test_CSVCaseIterator_read_external_file_without_header(self):
# Without a label column
csv_data = ['33.5, 76.2, "Hello There"\n'
'3.14159, 0, "Goodbye z"\n'
]
outfile = open(self.filename, 'w')
outfile.writelines(csv_data)
outfile.close()
header_dict = { 0 : "comp1.x",
1 : "comp1.y",
2 : "comp2.b_string",
}
self.top.comp2.add('b_string', Str("Hello',;','", iotype='in'))
sout = StringIO.StringIO()
self.top.driver.iterator = CSVCaseIterator(filename=self.filename, \
headers=header_dict)
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.run()
self.assertEqual(self.top.comp1.x, 3.14159)
self.assertEqual(self.top.comp1.y, 0.0)
self.assertEqual(self.top.comp2.b_string, "Goodbye z")
# With a label column
csv_data = ['"case1", 33.5, 76.2, "Hello There"\n'
]
header_dict = { 0 : "label",
1 : "comp1.x",
2 : "comp1.y",
3 : "comp2.b_string",
}
outfile = open(self.filename, 'w')
outfile.writelines(csv_data)
outfile.close()
self.top.driver.iterator = CSVCaseIterator(filename=self.filename, \
headers=header_dict)
self.top.driver.recorders = [ListCaseRecorder()]
self.top.run()
it = self.top.driver.recorders[0].get_iterator()
case1 = it.pop()
self.assertEqual(case1.label, 'case1')
def configure(self):
self.recorders = [ListCaseRecorder()]
self.add('driver2', CIDriver(3, 'comp2'))
self.add('comp2', CaseComponent())
self.driver2.workflow.add('comp2')
self.add('driver1', CIDriver(2, 'comp1'))
self.add('comp1', CaseComponent())
self.driver1.workflow.add(['comp1', 'driver2'])
self.driver.workflow.add('driver1')
def test_sequential(self):
logging.debug('')
logging.debug('test_sequential')
results = ListCaseRecorder()
self.model.driver.recorders = [results]
self.model.run()
for case in results.cases:
self.assertEqual(case.msg, None)
assert_rel_error(
self, case['driven.rosen_suzuki'],
rosen_suzuki(*[case['driven.x'][i] for i in range(4)]), 0.0001)
def test_recording_with_exception(self):
logging.debug('')
logging.debug('test_recording')
results = ListCaseRecorder()
self.model.driver.recorders = [
results,
]
self.model.run()
self.assertEqual(results.cases[0].msg,
"Cannot take square root of negative number")
self.assertEqual(type(results.cases[0].get_outputs()[0][1]),
MissingValue)
def test_noiterator(self):
logging.debug('')
logging.debug('test_noiterator')
# Check resoponse to no iterator set.
self.model.driver.recorders = [ListCaseRecorder()]
self.model.driver.printvars = ['driven.extra']
try:
self.model.run()
except ValueError as exc:
msg = "driver: iterator has not been set"
self.assertEqual(str(exc), msg)
else:
self.fail('ValueError expected')
def test_noiterator(self):
logging.debug('')
logging.debug('test_noiterator')
# Check resoponse to no iterator set.
self.model.driver.recorders = [ListCaseRecorder()]
self.model.driver.DOEgenerator = None
try:
self.model.run()
except Exception as exc:
msg = "driver: required plugin 'DOEgenerator' is not present"
self.assertEqual(str(exc), msg)
else:
self.fail('Exception expected')
def test_save_load(self):
logging.debug('')
logging.debug('test_save_load')
self.model.driver.iterator = ListCaseIterator(self.cases)
results = ListCaseRecorder()
self.model.driver.printvars = ['driven.extra']
self.model.driver.recorders = [results]
# Set local dir in case we're running in a different directory.
py_dir = self.directory
# Exercise check_save_load().
retcode = check_save_load(self.model, py_dir=py_dir)
self.assertEqual(retcode, 0)
def configure(self):
self.add('c0', C0_vt())
self.add('c1', C1_vt())
self.add('parallel_driver', CaseIteratorDriver())
self.driver.workflow.add(['c0', 'parallel_driver'])
N = 10
self.c0.N = N
self.parallel_driver.iterator = \
ListCaseIterator([Case(inputs=[('c1.i', l)]) for l in range(N)])
self.parallel_driver.workflow.add(['c1'])
self.parallel_driver.recorders.append(ListCaseRecorder())
self.parallel_driver.printvars = ['c1.val']
self.connect('c0.vt', 'c1.vt')
def test_nooutput(self):
logging.debug('')
logging.debug('test_nooutput')
results = ListCaseRecorder()
self.model.driver.recorders = [results]
self.model.driver.error_policy = 'RETRY'
self.model.driver.case_outputs.append('driven.sum_z')
self.model.run()
self.assertEqual(len(results),
self.model.driver.DOEgenerator.num_sample_points)
msg = "driver: Exception getting case outputs: " \
"driven: 'DrivenComponent' object has no attribute 'sum_z'"
for case in results.cases:
self.assertEqual(case.msg, msg)
def configure(self):
self.add("driver", DOEdriver())
self.recorders = [ListCaseRecorder()]
self.driver.DOEgenerator = FullFactorial()
# configure the specific DOE options
self.driver.DOEgenerator.num_levels = 3
self.add("dis1", sellar.Discipline1())
self.add("dis2", sellar.Discipline2())
# setting some variables to fixed values
self.dis1.y2 = 3.15
self.dis2.y1 = 3.78
# adding three parameters to the DOEDriver
self.driver.add_parameter(("dis1.z1", "dis2.z1"), low=-10.0, high=10.0)
self.driver.add_parameter(("dis1.z2", "dis2.z2"), low=0.0, high=10.0)
self.driver.add_parameter("dis1.x1", low=0.0, high=10.0)
def run_cases(self, sequential, forced_errors=False, retry=True):
# Evaluate cases, either sequentially or across multiple servers.
self.model.driver.sequential = sequential
results = ListCaseRecorder()
self.model.driver.recorders = [results]
self.model.driver.error_policy = 'RETRY' if retry else 'ABORT'
if forced_errors:
self.model.driver.add_event('driven.err_event')
if retry:
self.model.run()
self.assertEqual(len(results), 11)
self.verify_results(forced_errors)
else:
assert_raises(self, 'self.model.run()', globals(), locals(),
RuntimeError, "driver: Run aborted:"
" RuntimeError('driven: Forced error',)")
def test_nooutput(self):
logging.debug('')
logging.debug('test_nooutput')
results = ListCaseRecorder()
self.model.driver.recorders = [results]
self.model.driver.error_policy = 'RETRY'
self.model.driver.case_outputs.append('driven.sum_z')
self.model.run()
self.assertEqual(len(results), 1 + self.model.driver.DOEgenerator.num_samples)
for case in results.cases:
expected = "driver: Exception getting case outputs: " \
"driven \(UUID.[0-9]+-1\): " \
"'DrivenComponent' object has no attribute 'sum_z'"
msg = replace_uuid(case.msg)
self.assertTrue(re.match(expected, msg))
def test_forward(self):
model = set_as_top(ArrayModel())
driver = model.driver
results = ListCaseRecorder()
driver.recorders = [results]
driver.distribution_generator.form = "FORWARD"
driver.distribution_generator.order = 1
model.run()
# Verify recorded results match expectations.
num_params = driver.total_parameters()
self.assertEqual(len(results), 1 + num_params)
for case in results.cases:
self.assertEqual(case.msg, None)
self.assertEqual(case['driven.rosen_suzuki'],
rosen_suzuki(*[case['driven.x'][i] for i in range(4)]))
def configure(self):
self.add('paraboloid',Paraboloid())
self.add('driver',DOEdriver())
#There are a number of different kinds of DOE available in openmdao.lib.doegenerators
self.driver.DOEgenerator = FullFactorial(10) #Full Factorial DOE with 10 levels for each variable
#DOEdriver will automatically record the values of any parameters for each case
self.driver.add_parameter('paraboloid.x',low=-50,high=50)
self.driver.add_parameter('paraboloid.y',low=-50,high=50)
#tell the DOEdriver to also record any other variables you want to know for each case
self.driver.case_outputs = ['paraboloid.f_xy',]
#Simple recorder which stores the cases in memory.
self.driver.recorders = [ListCaseRecorder(),]
self.driver.workflow.add('paraboloid')
def test_AutoBEM_DOE(self):
# perform a DOE
self.top.replace('driver', DOEdriver())
self.top.driver.DOEgenerator = FullFactorial(3)
self.top.driver.recorders = [ListCaseRecorder()]
self.top.driver.case_outputs = [
'b.perf.data.tip_speed_ratio', 'b.perf.data.Cp', 'b.perf.data.Ct'
]
self.top.driver.add_parameter('b.chord_hub', low=.1, high=2)
self.top.driver.add_parameter('b.chord_tip', low=.1, high=2)
self.top.driver.add_parameter('b.rpm', low=20, high=300)
self.top.driver.add_parameter('b.twist_hub', low=-5, high=50)
self.top.driver.add_parameter('b.twist_tip', low=-5, high=50)
self.top.run()
self.assertEqual(len(self.top.driver.recorders[0]), 243)
def test_rerun(self):
logging.debug('')
logging.debug('test_rerun')
self.run_cases(sequential=True)
orig_cases = self.model.driver.recorders[0].cases
self.model.driver.iterator = ListCaseIterator(orig_cases)
rerun_seq = (1, 3, 5, 7, 9)
self.model.driver.filter = SequenceCaseFilter(rerun_seq)
rerun = ListCaseRecorder()
self.model.driver.printvars = ['driven.extra']
self.model.driver.recorders[0] = rerun
self.model.run()
self.assertEqual(len(orig_cases), 10)
self.assertEqual(len(rerun.cases), len(rerun_seq))
for i, case in enumerate(rerun.cases):
self.assertEqual(case, orig_cases[rerun_seq[i]])
def configure(self):
self.add('driver', CaseIteratorDriver())
self.add('runner', PGrafSubComponent())
self.driver.workflow.add('runner')
self.driver.sequential = False
# uncomment to keep simulation directories for debugging purposes
#import os
#os.environ['OPENMDAO_KEEPDIRS'] = '1'
cases = []
for num in range(4):
cases.append(
Case(inputs=[('runner.obj', PGrafObject(num)),
('runner.num', num)],
outputs=['runner.result']))
self.driver.iterator = ListCaseIterator(cases)
self.driver.recorders = [ListCaseRecorder()]
def test_rerun(self):
logging.debug('')
logging.debug('test_rerun')
self.run_cases(sequential=True)
orig_cases = self.model.driver.recorders[0].cases
self.model.driver.DOEgenerator = CSVFile(self.model.driver.doe_filename)
self.model.driver.record_doe = False
rerun_seq = (1, 3, 5, 7, 9)
self.model.driver.case_filter = SequenceCaseFilter(rerun_seq)
rerun = ListCaseRecorder()
self.model.driver.recorders[0] = rerun
self.model.run()
self.assertEqual(len(orig_cases), 10)
self.assertEqual(len(rerun.cases), len(rerun_seq))
for i, case in enumerate(rerun.cases):
self.assertEqual(case, orig_cases[rerun_seq[i]])
def test_invalid_form(self):
model = Assembly()
model.add('driver', DistributionCaseDriver())
model.add('driven', SimpleComponent())
model.driver.workflow.add('driven')
model.driver.distribution_generator = FiniteDifferenceGenerator(model.driver)
model.driver.case_outputs = ['driven.y']
model.driver.add_parameter("driven.x", low=-10., high=10., fd_step = 0.1 )
results = ListCaseRecorder()
model.driver.recorders = [results]
try:
model.driver.distribution_generator.form = "INVALID_FORM"
except ValueError, err:
msg = "Variable 'form' must be in ['CENTRAL', 'FORWARD', 'BACKWARD'], " \
"but a value of INVALID_FORM <type 'str'> was specified."
self.assertEqual(str(err), msg)
def test_invalid_case_outputs(self):
model = Assembly()
model.add('driver', DistributionCaseDriver())
model.add('driven', SimpleComponent())
model.driver.workflow.add('driven')
model.driver.distribution_generator = FiniteDifferenceGenerator(model.driver)
model.driver.case_outputs = ['driven.invalid']
model.driver.add_parameter("driven.x", low=-10., high=10., fd_step = 0.1 )
model.driver.error_policy = 'RETRY'
results = ListCaseRecorder()
model.driver.recorders = [results]
model.driver.distribution_generator.form = "FORWARD"
model.driver.distribution_generator.order = 2
model.run()
self.assertEqual(results.cases[0].items()[1][1], _Missing )
def configure(self):
"""Configures an assembly for running with the CaseIteratorDriver"""
self._logger.info("configuring dispatcher")
self.add('case_driver', ConnectableCaseIteratorDriver())
self.driver.workflow.add(['case_driver'])
self.add('runner', FUSEDAssembly())
self.case_driver.workflow.add('runner')
# Boolean for running sequentially or in parallel
self.create_passthrough('case_driver.sequential')
self.case_driver.recorders.append(ListCaseRecorder())
# component for postprocessing results
self.add('post', PostprocessCasesBase())
self.driver.workflow.add('post')
self.connect('case_driver.evaluated', 'post.cases')
self._logger.info("dispatcher configured")
def configure(self):
self.add('driver', CONMINdriver())
self.add('preproc', PreProc())
self.add('comp', OptRosenSuzukiComponent())
self.add('postproc', PostProc())
self.driver.workflow.add(('preproc', 'comp', 'postproc'))
self.driver.iprint = 0
self.driver.itmax = 30
self.connect('preproc.x_out', 'comp.x')
self.connect('comp.result', 'postproc.result_in')
self.driver.add_objective('postproc.result_out')
self.driver.add_parameter(('preproc.x_in[0]', 'preproc.x_in[1]',
'preproc.x_in[2]', 'preproc.x_in[3]'))
# pylint: disable=C0301
map(self.driver.add_constraint, [
'comp.x[0]**2+comp.x[0]+comp.x[1]**2-comp.x[1]+comp.x[2]**2+comp.x[2]+comp.x[3]**2-comp.x[3] < 8',
'comp.x[0]**2-comp.x[0]+2*comp.x[1]**2+comp.x[2]**2+2*comp.x[3]**2-comp.x[3] < 10',
'2*comp.x[0]**2+2*comp.x[0]+comp.x[1]**2-comp.x[1]+comp.x[2]**2-comp.x[3] < 5'])
self.recorders = [ListCaseRecorder()]
def test_opt1(self):
self.top.driver.add_objective('comp.result')
self.top.driver.add_parameter('comp.x[0]', -10.0, 99.0)
self.top.driver.add_parameter('comp.x[1]', -10.0, 99.0)
self.top.driver.add_parameter('comp.x[2]', -10.0, 99.0)
self.top.driver.add_parameter('comp.x[3]', -10.0, 99.0)
map(self.top.driver.add_constraint, [
'comp.x[0]**2+comp.x[0]+comp.x[1]**2-comp.x[1]+comp.x[2]**2+comp.x[2]+comp.x[3]**2-comp.x[3] < 8',
'comp.x[0]**2-comp.x[0]+2*comp.x[1]**2+comp.x[2]**2+2*comp.x[3]**2-comp.x[3] < 10',
'2*comp.x[0]**2+2*comp.x[0]+comp.x[1]**2-comp.x[1]+comp.x[2]**2-comp.x[3] < 5'
])
self.top.driver.recorders = [ListCaseRecorder()]
self.top.driver.printvars = ['comp.opt_objective']
self.top.run()
self.assertAlmostEqual(self.top.comp.opt_objective,
self.top.driver.eval_objective(),
places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[0],
self.top.comp.x[0],
places=1)
self.assertAlmostEqual(self.top.comp.opt_design_vars[1],
self.top.comp.x[1],
places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[2],
self.top.comp.x[2],
places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[3],
self.top.comp.x[3],
places=1)
cases = self.top.driver.recorders[0].get_iterator()
end_case = cases[-1]
self.assertEqual(self.top.comp.x[1], end_case.get_input('comp.x[1]'))
self.assertEqual(self.top.comp.opt_objective,
end_case.get_output('comp.opt_objective'))
def test_run_stop_step_resume(self):
logging.debug('')
logging.debug('test_run_stop_step_resume')
self.generate_cases()
stop_case = self.cases[1] # Stop after 2 cases run.
stop_case['driven.stop_exec'] = True
self.model.driver.iterator = ListCaseIterator(self.cases)
results = ListCaseRecorder()
self.model.driver.recorders = [results]
self.model.driver.printvars = ['driven.extra']
self.model.driver.sequential = True
try:
self.model.run()
except RunStopped:
self.assertEqual(len(results), 2)
self.verify_results()
else:
self.fail('Expected RunStopped')
self.model.driver.step()
self.assertEqual(len(results), 3)
self.verify_results()
self.model.driver.step()
self.assertEqual(len(results), 4)
self.verify_results()
self.model.driver.resume()
self.assertEqual(len(results), len(self.cases))
self.verify_results()
try:
self.model.driver.resume()
except RuntimeError as exc:
self.assertEqual(str(exc), 'driver: Run already complete')
else:
self.fail('Expected RuntimeError')
def configure(self):
self.add('paraboloid', Paraboloid())
doe = self.add('driver', DOEdriver())
doe.DOEgenerator = Uniform(num_samples=1000)
doe.add_parameter('paraboloid.x', low=-50, high=50)
doe.add_parameter('paraboloid.y', low=-50, high=50)
doe.case_outputs = ['paraboloid.f_xy']
doe.workflow.add('paraboloid')
if __name__ == '__main__':
analysis = Analysis()
# Run full experiment and record results.
recorder = ListCaseRecorder()
analysis.driver.recorders = [recorder]
analysis.run()
# Reconfigure driver.
workflow = analysis.driver.workflow
analysis.add('driver', CaseIteratorDriver())
analysis.driver.workflow = workflow
# Rerun cases where paraboloid.f_xy <= 0.
analysis.driver.iterator = recorder.get_iterator()
analysis.driver.filter = ExprCaseFilter("case['paraboloid.f_xy'] <= 0")
analysis.run()
# Rerun cases which failed.
analysis.driver.iterator = recorder.get_iterator()
