def generate_cases(self):
""" Generate cases to be run based on configuration. """
nvars = len(self.design_variables)
if self.type == 'ccd':
# CCD requires an exact value
if nvars == 1:
min_samples = 3
else:
min_samples = 2 ** nvars + 2 * nvars + 1
if self.n_samples != min_samples:
self._logger.warning('Setting n_samples to CCD required value: %d' % \
min_samples)
self.n_samples = min_samples
elif self.type == 'lhs':
min_samples = nvars
elif self.type == 'rand_lhs':
min_samples = nvars
elif self.type == 'oa2':
min_samples = (nvars - 1) ** 2
elif self.type == 'oa3':
min_samples = (nvars - 1) ** 3
else:
self._logger.error("Unknown type '%s'" % self.type)
return None
if self.n_samples < min_samples:
self._logger.warning('Updating n_samples to minimum: %d' % min_samples)
self.n_samples = min_samples
xmin = []
xmax = []
for name, min_val, max_val in self.design_variables:
xmin.append(min_val)
xmax.append(max_val)
doe = mool.Optimization.DOE.DOE(xmin, xmax, self.type, self.n_samples,
self.lhs)
sample_points = doe.x
cases = []
for point in sample_points:
inputs = []
for i, var in enumerate(self.design_variables):
inputs.append((var[0], None, point[i]))
outputs = []
for var in self.response_variables:
outputs.append((var, None, None))
cases.append(Case(inputs, outputs))
return cases
def setup_cases(self):
"""
setup the cases to run
This method has to be called after instantiation of the class, once the ``cases``
list has been set.
"""
self.runcases = []
for case in self.cases:
self._logger.info('Adding case %s' % case.case_name)
self.runcases.append(
Case(inputs=[('runner.inputs', case)],
outputs=['runner.outputs']))
self.case_driver.iterator = ListCaseIterator(self.runcases)
def setUp(self):
self.top = top = set_as_top(Assembly())
driver = top.add('driver', SimpleCaseIterDriver())
top.add('comp1', ExecComp(exprs=['z=x+y']))
top.add('comp2', ExecComp(exprs=['z=x+1']))
top.connect('comp1.z', 'comp2.x')
driver.workflow.add(['comp1', 'comp2'])
# now create some Cases
outputs = ['comp1.z', 'comp2.z']
cases = []
for i in range(10):
inputs = [('comp1.x', i), ('comp1.y', i * 2)]
cases.append(
Case(inputs=inputs, outputs=outputs, label='case%s' % i))
driver.iterator = ListCaseIterator(cases)
def test_query(self):
recorder = DBCaseRecorder()
for i in range(10):
inputs = [('comp1.x', i), ('comp1.y', i * 2.)]
outputs = [('comp1.z', i * 1.5),
('comp2.normal', NormalDistribution(float(i), 0.5))]
recorder.record(
Case(inputs=inputs, outputs=outputs, label='case%s' % i))
iterator = recorder.get_iterator()
iterator.selectors = ["value>=0", "value<3"]
count = 0
for i, case in enumerate(iterator):
count += 1
for name, value in case.items():
self.assertTrue(value >= 0 and value < 3)
def test_flatten(self):
# create some Cases
outputs = ['comp1.a_array', 'comp1.vt']
inputs = [('comp1.x_array', array([2.0, 2.0, 2.0]))]
cases = [Case(inputs=inputs, outputs=outputs)]
self.top.driver.clear_parameters()
Case.set_vartree_inputs(self.top.driver, cases)
self.top.driver.clear_responses()
self.top.driver.add_responses(outputs)
self.top.recorders = [CSVCaseRecorder(filename=self.filename)]
self.top.recorders[0].num_backups = 0
self.top.run()
# check recorded cases
cases = [case for case in self.top.recorders[0].get_iterator()]
def setUp(self):
self.top = set_as_top(Assembly())
self.top.add('comp1', Simple())
self.top.add('comp2', Simple())
self.top.connect('comp1.c', 'comp2.a')
self.top.connect('comp1.d', 'comp2.b')
self.top.connect('comp1.c_lst', 'comp2.a_lst')
self.top.driver.workflow.add(['comp1', 'comp2'])
self.inputs = [('comp1.a', 2), ('comp1.b', 4),
('comp1.a_lst', [4, 5, 6])]
self.outputs = ['comp2.c+comp2.d', 'comp2.c_lst[2]', 'comp2.d']
self.case = case = Case(inputs=self.inputs, outputs=self.outputs)
case.apply_inputs(self.top)
self.top.run()
case.update_outputs(self.top)
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 setUp(self):
self.top = top = set_as_top(Assembly())
driver = top.add('driver', SimpleCaseIterDriver())
top.add('comp1', ExecComp(exprs=['z=x+y']))
top.add('comp2', ExecComp(exprs=['z=x+1']))
top.connect('comp1.z', 'comp2.x')
driver.workflow.add(['comp1', 'comp2'])
# now create some Cases
outputs = ['comp1.z', 'comp2.z']
cases = []
for i in range(10):
inputs = [('comp1.x', i), ('comp1.y', i * 2)]
cases.append(Case(inputs=inputs, outputs=outputs))
Case.set_vartree_inputs(driver, cases)
driver.add_responses(outputs)
def test_flatten(self):
# create some Cases
outputs = ['comp1.a_array', 'comp1.vt']
inputs = [('comp1.x_array', array([2.0, 2.0, 2.0]))]
self.top.driver.iterator = ListCaseIterator(
[Case(inputs=inputs, outputs=outputs, label='case1')])
self.top.driver.recorders = [CSVCaseRecorder(filename=self.filename)]
self.top.driver.recorders[0].num_backups = 0
self.top.run()
# now use the CSV recorder as source of Cases
self.top.driver.iterator = self.top.driver.recorders[0].get_iterator()
sout = StringIO.StringIO()
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.run()
expected = [
'Case: case1',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' inputs:',
' comp1.x_array[0]: 2.0',
' comp1.x_array[1]: 2.0',
' comp1.x_array[2]: 2.0',
' outputs:',
" comp1.a_array[0]: 1.0",
" comp1.a_array[1]: 3.0",
" comp1.a_array[2]: 5.5",
" comp1.vt.v1: 1.0",
" comp1.vt.v2: 2.0",
" comp1.vt.vt2.vt3.a: 1.0",
" comp1.vt.vt2.vt3.b: 12.0",
" comp1.vt.vt2.x: -1.0",
" comp1.vt.vt2.y: -2.0",
]
lines = sout.getvalue().split('\n')
for index, line in enumerate(lines):
if line.startswith('Case: case1'):
for i in range(len(expected)):
if expected[i].startswith(' uuid:'):
self.assertTrue(lines[index +
i].startswith(' uuid:'))
else:
self.assertEqual(lines[index + i], expected[i])
break
else:
self.fail("couldn't find the expected Case")
def test_pickle_conversion(self):
recorder = DBCaseRecorder()
for i in range(10):
inputs = [('comp1.x', i), ('comp1.y', i * 2.)]
outputs = [('comp1.z', i * 1.5),
('comp2.normal', NormalDistribution(float(i), 0.5))]
recorder.record(
Case(inputs=inputs, outputs=outputs, label='case%s' % i))
iterator = recorder.get_iterator()
for i, case in enumerate(iterator):
self.assertTrue(
isinstance(case['comp2.normal'], NormalDistribution))
self.assertEqual(case['comp2.normal'].mu, float(i))
self.assertEqual(case['comp2.normal'].sigma, 0.5)
self.assertTrue(isinstance(case['comp1.y'], float))
self.assertEqual(case['comp1.y'], i * 2.)
self.assertEqual(case['comp1.z'], i * 1.5)
def test_sorting(self):
# Make sure outputs are sorted
rec = CSVCaseRecorder(filename=self.filename)
rec.num_backups = 0
rec.startup()
rec.record(
Case(inputs=[('comp1.x', 2.0), ('comp1.y', 4.3), ('comp2.x',
1.9)]))
rec.close()
outfile = open(self.filename, 'r')
csv_data = outfile.readlines()
outfile.close()
line = '"label","/INPUTS","comp1.x","comp1.y","comp2.x","/OUTPUTS","/METADATA","retries","max_retries","parent_uuid","msg"\r\n'
self.assertEqual(csv_data[0], line)
line = '"","",2.0,4.3,1.9,"","","","","",""\r\n'
self.assertEqual(csv_data[1], line)
def setUp(self):
self.top = top = set_as_top(Assembly())
driver = top.add('driver', CaseIteratorDriver())
top.add('comp1', TExecComp(exprs=['z=x+y']))
top.add('comp2', ExecComp(exprs=['z=x+1']))
top.connect('comp1.z', 'comp2.x')
driver.workflow.add(['comp1', 'comp2'])
# now create some Cases
outputs = ['comp1.z', 'comp2.z']
cases = []
for i in range(10):
i = float(i)
inputs = [('comp1.x', i), ('comp1.y', i * 2)]
cases.append(Case(inputs=inputs, outputs=outputs))
Case.set_vartree_inputs(driver, cases)
driver.add_responses(outputs)
self.tempdir = tempfile.mkdtemp(prefix='test_jsonrecorder-')
def execute(self):
""" Runs with various box parameter values. """
for width in range(1, 2):
for height in range(1, 3):
for depth in range(1, 4):
self._logger.debug('w,h,d %s, %s, %s', width, height, depth)
self.set_parameters((width, height, depth))
self.workflow.run()
volume, area = self.eval_objectives()
self._logger.debug(' v,a %s, %s', volume, area)
case = Case()
case.inputs = [('width', None, width),
('height', None, height),
('depth', None, depth)]
case.outputs = [('volume', None, volume),
('area', None, area),
('pid', None, self.parent.box.pid)]
# Just to show access to remote from driver.
for recorder in self.recorders:
recorder.record(case)
def setUp(self):
self.top = top = set_as_top(Assembly())
comp1 = top.add('comp1', ExecComp(exprs=['z=x*y+100']))
comp2 = top.add('comp2', ExecComp(exprs=['z=x*.4']))
top.connect('comp1.z', 'comp2.x')
driver = top.add('driver', SimpleCaseIterDriver())
driver.workflow.add([comp1, comp2])
plotter = top.add('plotter', XYplotter())
plotter.title = "Foobar"
#plotter.add_line(y="comp1.z", line_type='bo-')
plotter.add_line(x="comp1.x", y="comp1.z", line_type='bo-')
plotter.add_line(x='comp1.x', y="comp2.z", line_type='rD-', label='blah')
# now create some Cases
outputs = [('comp1.z', None, None), ('comp2.z', None, None)]
cases = []
for i in range(10):
inputs = [('comp1.x', None, i), ('comp1.y', None, i*2)]
cases.append(Case(inputs=inputs, outputs=outputs, ident='case%s'%i))
driver.iterator = ListCaseIterator(cases)
def test_flatten(self):
# try it after creating some Cases
# more rigorous checking of the csv
outputs = ['comp1.a_array', 'comp1.vt']
inputs = [('comp1.x_array', array([2.0, 2.0, 2.0]))]
cases = [Case(inputs=inputs, outputs=outputs)]
self.top.driver.clear_parameters()
Case.set_vartree_inputs(self.top.driver, cases)
self.top.driver.clear_responses()
self.top.driver.add_responses(outputs)
self.top.recorders = [JSONCaseRecorder(self.filename_json)]
self.top.recorders[0].num_backups = 0
self.top.run()
cds = CaseDataset(self.filename_json, 'json')
data = cds.data.fetch() # results
caseset_query_to_csv(data, self.filename_csv)
# check recorded cases
cases = [case for case in CSVCaseIterator(filename=self.filename_csv)]
def test_db_to_dict(self):
tmpdir = tempfile.mkdtemp()
dfile = os.path.join(tmpdir, 'junk.db')
recorder = DBCaseRecorder(dfile)
# create some Cases where some are missing a variable
outputs = ['comp1.z', 'comp2.z']
cases = []
for i in range(10):
if i > 1:
msg = ''
else:
msg = 'an error occurred'
if i < 5:
inputs = [('comp1.x', i), ('comp1.y', i * 2),
('comp1.y2', i * 3)]
else:
inputs = [('comp1.x', i), ('comp1.y', i * 2)]
recorder.record(Case(inputs=inputs, outputs=outputs, msg=msg))
varnames = ['comp1.x', 'comp1.y', 'comp1.y2']
varinfo = case_db_to_dict(dfile, varnames)
self.assertEqual(len(varinfo), 3)
# each var list should have 3 data values in it (5 with the required variables minus
# 2 with errors
for name, lst in varinfo.items():
self.assertEqual(len(lst), 3)
# now use caseiter_to_dict to grab the same data
varinfo = caseiter_to_dict(recorder.get_iterator(), varnames)
# each var list should have 3 data values in it (5 with the required variables minus
# 2 with errors
for name, lst in varinfo.items():
self.assertEqual(len(lst), 3)
try:
shutil.rmtree(tmpdir)
except OSError:
logging.error("problem removing directory %s" % tmpdir)
def setUp(self):
self.top = top = set_as_top(Assembly())
driver = top.add('driver', SimpleCaseIterDriver())
top.add('comp1', ExecComp(exprs=['z=x+y']))
top.add('comp2', ExecComp(exprs=['z=x+1']))
top.connect('comp1.z', 'comp2.x')
top.comp1.add('a_string', Str("Hello',;','", iotype='out'))
top.comp1.add('a_array', Array(array([1.0, 3.0, 5.5]), iotype='out'))
top.comp1.add('x_array', Array(array([1.0, 1.0, 1.0]), iotype='in'))
top.comp1.add('vt', Slot(DumbVT, iotype='out'))
top.comp1.vt = DumbVT()
driver.workflow.add(['comp1', 'comp2'])
# now create some Cases
outputs = ['comp1.z', 'comp2.z', 'comp1.a_string', 'comp1.a_array[2]']
cases = []
for i in range(10):
inputs = [('comp1.x', i+0.1), ('comp1.y', i*2 + .1), ('comp1.x_array[1]', 99.88)]
cases.append(Case(inputs=inputs, outputs=outputs, label='case%s'%i))
driver.iterator = ListCaseIterator(cases)
self.filename = "openmdao_test_csv_case_iterator.csv"
def setUp(self):
self.top = top = set_as_top(Assembly())
driver = top.add('driver', SimpleCaseIterDriver())
top.add('comp1', ExecComp(exprs=['z=x+y']))
top.add('comp2', ExecComp(exprs=['z=x+1']))
top.comp1.add('a_dict', Dict({}, iotype='in'))
top.comp1.add('a_list', List([], iotype='in'))
top.connect('comp1.z', 'comp2.x')
driver.workflow.add(['comp1', 'comp2'])
# now create some Cases
outputs = ['comp1.z', 'comp2.z']
cases = []
for i in range(10):
i = float(i)
inputs = [('comp1.x', i), ('comp1.y', i * 2),
('comp1.a_dict', {
'a': 'b'
}), ('comp1.a_list', ['a', 'b'])]
cases.append(Case(inputs=inputs, outputs=outputs))
Case.set_vartree_inputs(driver, cases)
driver.add_responses(outputs)
def test_flatten(self):
dvt = DumbVT()
inputs = [
('comp1.a_lst', [1, 2, 3, [7, 8, 9]]),
('comp1.a_arr', array.array('d', [4, 5, 6])),
('comp1.np_arr', nparray([[1, 2], [3, 4], [5, 6]])),
('comp1.vt', dvt),
]
case = Case(inputs=inputs)
self.assertEqual(
set(case.items(flatten=True)),
set([('comp1.a_lst[0]', 1), ('comp1.a_lst[1]', 2),
('comp1.a_lst[2]', 3), ('comp1.a_lst[3][0]', 7),
('comp1.a_lst[3][1]', 8), ('comp1.a_lst[3][2]', 9),
('comp1.a_arr[0]', 4.0), ('comp1.a_arr[1]', 5.0),
('comp1.a_arr[2]', 6.0), ('comp1.np_arr[0][0]', 1),
('comp1.np_arr[0][1]', 2), ('comp1.np_arr[1][0]', 3),
('comp1.np_arr[1][1]', 4), ('comp1.np_arr[2][0]', 5),
('comp1.np_arr[2][1]', 6), ('comp1.vt.vt2.vt3.a', 1.),
('comp1.vt.vt2.vt3.b', 12.), ('comp1.vt.vt2.x', -1.),
('comp1.vt.vt2.y', -2.), ('comp1.vt.v1', 1.),
('comp1.vt.v2', 2.)]))
def __init__(self):
"""Creates an Assembly to run DREA and HSRnoise."""
super(DREA_HSRnoise, self).__init__()
FO1 = Case(inputs=[('point', 1),('dreaprep.Mach',0.28),('alt',2000.0),('dreaprep.PC',100.0),('hsrnoise.phi', 0.0)], outputs=[('drea.CFG',0.0),('hsrnoise.thetas',0.0),('hsrnoise.Freq',0.0),('hsrnoise.SPL_corr',0),('hsrnoise.OASPL30',0.0),('hsrnoise.OASPL60',0.0),('hsrnoise.OASPL90',0.0),('hsrnoise.OASPL120',0.0),('hsrnoise.OASPL150',0.0)])
FO2 = Case(inputs=[('point', 1),('dreaprep.Mach',0.28),('alt',2000.0),('dreaprep.PC', 65.0),('hsrnoise.phi', 0.0)], outputs=[('drea.CFG',0.0),('hsrnoise.thetas',0.0),('hsrnoise.Freq',0.0),('hsrnoise.SPL_corr',0),('hsrnoise.OASPL30',0.0),('hsrnoise.OASPL60',0.0),('hsrnoise.OASPL90',0.0),('hsrnoise.OASPL120',0.0),('hsrnoise.OASPL150',0.0)])
App = Case(inputs=[('point', 2),('dreaprep.Mach',0.20),('alt', 394.0),('dreaprep.PC', 30.0),('hsrnoise.phi', 0.0)], outputs=[('drea.CFG',0.0),('hsrnoise.thetas',0.0),('hsrnoise.Freq',0.0),('hsrnoise.SPL_corr',0),('hsrnoise.OASPL30',0.0),('hsrnoise.OASPL60',0.0),('hsrnoise.OASPL90',0.0),('hsrnoise.OASPL120',0.0),('hsrnoise.OASPL150',0.0)])
SL1 = Case(inputs=[('point', 3),('dreaprep.Mach',0.25),('alt',1000.0),('dreaprep.PC',100.0),('hsrnoise.phi', 0.0)], outputs=[('drea.CFG',0.0),('hsrnoise.thetas',0.0),('hsrnoise.Freq',0.0),('hsrnoise.SPL_corr',0),('hsrnoise.OASPL30',0.0),('hsrnoise.OASPL60',0.0),('hsrnoise.OASPL90',0.0),('hsrnoise.OASPL120',0.0),('hsrnoise.OASPL150',0.0)])
SL2 = Case(inputs=[('point', 3),('dreaprep.Mach',0.25),('alt',1000.0),('dreaprep.PC',100.0),('hsrnoise.phi',30.0)], outputs=[('drea.CFG',0.0),('hsrnoise.thetas',0.0),('hsrnoise.Freq',0.0),('hsrnoise.SPL_corr',0),('hsrnoise.OASPL30',0.0),('hsrnoise.OASPL60',0.0),('hsrnoise.OASPL90',0.0),('hsrnoise.OASPL120',0.0),('hsrnoise.OASPL150',0.0)])
SL3 = Case(inputs=[('point', 3),('dreaprep.Mach',0.25),('alt',1000.0),('dreaprep.PC',100.0),('hsrnoise.phi',60.0)], outputs=[('drea.CFG',0.0),('hsrnoise.thetas',0.0),('hsrnoise.Freq',0.0),('hsrnoise.SPL_corr',0),('hsrnoise.OASPL30',0.0),('hsrnoise.OASPL60',0.0),('hsrnoise.OASPL90',0.0),('hsrnoise.OASPL120',0.0),('hsrnoise.OASPL150',0.0)])
SL4 = Case(inputs=[('point', 3),('dreaprep.Mach',0.25),('alt',1000.0),('dreaprep.PC',100.0),('hsrnoise.phi',90.0)], outputs=[('drea.CFG',0.0),('hsrnoise.thetas',0.0),('hsrnoise.Freq',0.0),('hsrnoise.SPL_corr',0),('hsrnoise.OASPL30',0.0),('hsrnoise.OASPL60',0.0),('hsrnoise.OASPL90',0.0),('hsrnoise.OASPL120',0.0),('hsrnoise.OASPL150',0.0)])
cases = ListCaseIterator([FO1,FO2,App,SL1,SL2,SL3,SL4])
db_recorder = DBCaseRecorder()
self.add('geo', Geometry())
self.add('dreaprep', DREAprep())
self.add('drea', DREA())
self.add('hsrnoise', HSRNOISE())
self.add('ACDgen', ACDgen())
self.add('analysis',CaseIteratorDriver())
self.analysis.iterator = cases
self.analysis.recorders = [db_recorder]
self.ACDgen.case_data = db_recorder.get_iterator()
# Set up the workflows
#---------------------------
#self.analysis.workflow.add(['dreaprep', 'drea', 'hsrnoise'])
#self.driver.workflow.add(['analysis','ACDgen'])
self.driver.workflow.add(['dreaprep', 'drea', 'hsrnoise'])
# Connections
#---------------------------
self.connect('geo',['drea.geo_in','hsrnoise.geo_in'])
self.connect('alt',['dreaprep.alt','hsrnoise.ALTEVO'])
self.connect('dreaprep.flow_out','drea.flow_in')
self.connect('drea.flow_out','hsrnoise.flow_in')
self.connect('drea.CFG','hsrnoise.CFG')
def test_inoutCSV_empty_inputs(self):
# now create some Cases
outputs = ['comp1.z']
cases = []
for i in range(10):
cases.append(Case(inputs=[], outputs=outputs, label='case%s' % i))
self.top.driver.iterator = ListCaseIterator(cases)
self.top.driver.recorders = [CSVCaseRecorder(filename=self.filename)]
self.top.driver.recorders[0].num_backups = 0
self.top.run()
# now use the CSV recorder as source of Cases
self.top.driver.iterator = self.top.driver.recorders[0].get_iterator()
sout = StringIO.StringIO()
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.run()
expected = [
'Case: case8',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' outputs:',
' comp1.z: 0.0',
]
lines = sout.getvalue().split('\n')
for index, line in enumerate(lines):
if line.startswith('Case: case8'):
for i in range(len(expected)):
if expected[i].startswith(' uuid:'):
self.assertTrue(lines[index +
i].startswith(' uuid:'))
else:
self.assertEqual(lines[index + i], expected[i])
break
else:
self.fail("couldn't find the expected Case")
def test_noinput(self):
logging.debug('')
logging.debug('test_noinput')
# Create cases with missing input 'dc.z'.
cases = []
for i in range(2):
inputs = [('driven.x', numpy_random.normal(size=4)),
('driven.z', numpy_random.normal(size=10))]
outputs = [('driven.rosen_suzuki', None), ('driven.sum_y', None)]
cases.append(Case(inputs, outputs))
self.model.driver.iterator = ListCaseIterator(cases)
results = ListCaseRecorder()
self.model.driver.recorders = [results]
self.model.driver.printvars = ['driven.extra']
self.model.run()
self.assertEqual(len(results), len(cases))
msg = "driver: Exception setting case inputs:" \
" driven: object has no attribute 'z'"
for case in results.cases:
self.assertEqual(case.msg, msg)
def setUp(self):
self.startdir = os.getcwd()
self.tempdir = tempfile.mkdtemp(prefix='test_csv-')
os.chdir(self.tempdir)
self.top = top = set_as_top(Assembly())
driver = top.add('driver', SimpleCaseIterDriver())
top.add('comp1', ExecComp(exprs=['z=x+y']))
top.add('comp2', ExecComp(exprs=['z=x+1']))
top.connect('comp1.z', 'comp2.x')
top.comp1.add('a_string', Str("Hello',;','", iotype='out'))
top.comp1.add('a_array', Array(array([1.0, 3.0, 5.5]), iotype='out'))
top.comp1.add('x_array', Array(array([1.0, 1.0, 1.0]), iotype='in'))
top.comp1.add('b_bool', Bool(False, iotype='in'))
top.comp1.add('vt', VarTree(DumbVT(), iotype='out'))
driver.workflow.add(['comp1', 'comp2'])
# now create some Cases
outputs = ['comp1.z', 'comp2.z', 'comp1.a_string', 'comp1.a_array[2]']
cases = []
for i in range(10):
i = float(i)
inputs = [('comp1.x', i+0.1), ('comp1.y', i*2 + .1),
('comp1.x_array[1]', 99.88), ('comp1.b_bool', True)]
cases.append(Case(inputs=inputs, outputs=outputs))
Case.set_vartree_inputs(driver, cases)
driver.add_responses(sorted(outputs))
self.filename_json = "openmdao_test_csv_case_iterator.json"
self.filename_csv = "openmdao_test_csv_case_iterator.csv"
def test_close(self):
# :memory: can be used after close.
recorder = DBCaseRecorder()
case = Case(inputs=[('str', 'Normal String'),
('unicode', u'Unicode String'),
('list', ['Hello', 'world'])]) # Check pickling.
recorder.record(case)
recorder.close()
recorder.record(case)
# File-based DB recorder can not be used after close.
tmpdir = tempfile.mkdtemp()
try:
dfile = os.path.join(tmpdir, 'junk.db')
recorder = DBCaseRecorder(dfile)
recorder.record(case)
recorder.close()
assert_raises(self, 'recorder.record(case)', globals(), locals(),
RuntimeError, 'Attempt to record on closed recorder')
finally:
try:
shutil.rmtree(tmpdir, onerror=onerror)
except OSError:
logging.error("problem removing directory %s" % tmpdir)
def test_list(self):
outputs = ['z1', 'z2']
cases = []
for i in range(5):
inputs = [('x', i), ('y', i*2)]
cases.append(Case(inputs, outputs))
iterator = ListCaseIterator(cases)
for i, case in enumerate(iterator):
self.assertEqual(len(case.items(iotype='in')), 2)
self.assertEqual(len(case.items(iotype='out')), 2)
self.assertTrue('x' in case)
self.assertEqual(case['x'], i)
self.assertTrue('y' in case)
self.assertEqual(case['y'], i*2)
self.assertTrue('z1' in case)
self.assertEqual(case['z1'], _Missing)
self.assertTrue('z2' in case)
self.assertEqual(case['z2'], _Missing)
self.assertEqual(i, 4)
class CaseTestCase(unittest.TestCase):
def setUp(self):
self.top = set_as_top(Assembly())
self.top.add('comp1', Simple())
self.top.add('comp2', Simple())
self.top.connect('comp1.c', 'comp2.a')
self.top.connect('comp1.d', 'comp2.b')
self.top.connect('comp1.c_lst', 'comp2.a_lst')
self.top.driver.workflow.add(['comp1', 'comp2'])
self.inputs = [('comp1.a', 2), ('comp1.b', 4),
('comp1.a_lst', [4, 5, 6])]
self.outputs = ['comp2.c+comp2.d', 'comp2.c_lst[2]', 'comp2.d']
self.case = case = Case(inputs=self.inputs, outputs=self.outputs)
case.apply_inputs(self.top)
self.top.run()
case.update_outputs(self.top)
def test_subcase(self):
subcase = self.case.subcase(['comp1.b', 'comp2.d'])
self.assertEqual(self.case.timestamp, subcase.timestamp)
self.assertEqual(len(subcase.get_inputs()), 1)
self.assertEqual(subcase['comp1.b'], 4)
self.assertEqual(len(subcase.get_outputs()), 1)
self.assertEqual(subcase.get_outputs()[0][0], 'comp2.d')
def test_case_access(self):
self.assertEqual(self.case['comp1.a'], 2)
self.assertEqual(self.case['comp2.c_lst[2]'], 24)
self.case['comp1.a'] = 5
self.assertEqual(self.case['comp1.a'], 5)
def test_case_containment(self):
self.assertTrue('comp1.a' in self.case)
self.assertFalse('comp1.z' in self.case)
self.assertTrue('comp2.c+comp2.d' in self.case)
def test_len(self):
self.assertEqual(len(self.case), 6)
def test_str(self):
expected = [
"Case:",
" uuid: sdfsfdasfdasdf",
' timestamp: 1383239074.309192',
" inputs:",
" comp1.a: 2",
" comp1.a_lst: [4, 5, 6]",
" comp1.b: 4",
" outputs:",
" comp2.c+comp2.d: 12",
" comp2.c_lst[2]: 24",
" comp2.d: 8",
"",
]
for i, line in enumerate(str(self.case).split('\n')):
if expected[i].startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
elif expected[i].startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
else:
self.assertEqual(line, expected[i])
case = Case(inputs=[('comp1.a', 4), ('comp1.b', 8)],
case_uuid='abcd-efg',
parent_uuid='abc-xyz-pdq')
expected = [
"Case:",
" uuid: abcd-efg",
' timestamp: 1383239074.309192',
" parent_uuid: abc-xyz-pdq",
" inputs:",
" comp1.a: 4",
" comp1.b: 8",
"",
]
for i, line in enumerate(str(case).split('\n')):
if expected[i].startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
else:
self.assertEqual(line, expected[i])
class CaseTestCase(unittest.TestCase):
def setUp(self):
self.top = set_as_top(Assembly())
self.top.add('comp1', Simple())
self.top.add('comp2', Simple())
self.top.connect('comp1.c', 'comp2.a')
self.top.connect('comp1.d', 'comp2.b')
self.top.connect('comp1.c_lst', 'comp2.a_lst')
self.top.driver.workflow.add(['comp1', 'comp2'])
self.inputs = [('comp1.a', 2), ('comp1.b', 4),
('comp1.a_lst', [4, 5, 6])]
self.outputs = ['comp2.c+comp2.d', 'comp2.c_lst[2]', 'comp2.d']
self.case = case = Case(inputs=self.inputs,
outputs=self.outputs,
label='blah blah')
case.apply_inputs(self.top)
self.top.run()
case.update_outputs(self.top)
def test_case_access(self):
self.assertEqual(self.case['comp1.a'], 2)
self.assertEqual(self.case['comp2.c_lst[2]'], 24)
self.case['comp1.a'] = 5
self.assertEqual(self.case['comp1.a'], 5)
def test_case_containment(self):
self.assertTrue('comp1.a' in self.case)
self.assertFalse('comp1.z' in self.case)
self.assertTrue('comp2.c+comp2.d' in self.case)
def test_len(self):
self.assertEqual(len(self.case), 6)
def test_str(self):
expected = [
"Case: blah blah",
" uuid: sdfsfdasfdasdf",
" inputs:",
" comp1.a: 2",
" comp1.a_lst: [4, 5, 6]",
" comp1.b: 4",
" outputs:",
" comp2.c+comp2.d: 12",
" comp2.c_lst[2]: 24",
" comp2.d: 8",
"",
]
for i, line in enumerate(str(self.case).split('\n')):
if expected[i].startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
else:
self.assertEqual(line, expected[i])
case = Case(inputs=[('comp1.a', 4), ('comp1.b', 8)],
label='foo',
case_uuid='abcd-efg',
parent_uuid='abc-xyz-pdq',
max_retries=5,
retries=4,
msg='failed')
expected = [
"Case: foo",
" uuid: abcd-efg",
" parent_uuid: abc-xyz-pdq",
" inputs:",
" comp1.a: 4",
" comp1.b: 8",
" max_retries: 5",
" retries: 4",
" msg: failed",
"",
]
for i, line in enumerate(str(case).split('\n')):
self.assertEqual(line, expected[i])
def execute(self):
"""If the training flag is set, train the metamodel. Otherwise,
predict outputs.
"""
if self._train:
try:
inputs = self.update_model_inputs()
self.model.run(force=True)
except Exception as err:
if self.report_errors:
raise err
else:
self._failed_training_msgs.append(str(err))
else: # if no exceptions are generated, save the data
self._training_input_history.append(inputs)
self.update_outputs_from_model()
case_outputs = []
for name, output_history in self._training_data.items():
case_outputs.append(('.'.join([self.name, name]),
output_history[-1]))
# save the case, making sure to add out name to the local input
# name since this Case is scoped to our parent Assembly
case_inputs = [('.'.join([self.name, name]), val)
for name, val in zip(self.surrogate_input_names(),
inputs)]
if self.recorder:
self.recorder.record(Case(inputs=case_inputs,
outputs=case_outputs))
self._train = False
else:
# NO surrogates defined. just run model and get outputs
if self.default_surrogate is None and not self._surrogate_overrides:
inputs = self.update_model_inputs()
self.model.run()
self.update_outputs_from_model()
return
if self._new_train_data:
if len(self._training_input_history) < 2:
self.raise_exception("ERROR: need at least 2 training points!",
RuntimeError)
# figure out if we have any constant training inputs
tcases = self._training_input_history
in_hist = tcases[0][:]
# start off assuming every input is constant
idxlist = range(len(in_hist))
self._const_inputs = dict(zip(idxlist, in_hist))
for i in idxlist:
val = in_hist[i]
for case in range(1, len(tcases)):
if val != tcases[case][i]:
del self._const_inputs[i]
break
if len(self._const_inputs) == len(in_hist):
self.raise_exception("ERROR: all training inputs are constant.")
elif len(self._const_inputs) > 0:
# some inputs are constant, so we have to remove them from the training set
training_input_history = []
for inputs in self._training_input_history:
training_input_history.append([val for i, val in enumerate(inputs)
if i not in self._const_inputs])
else:
training_input_history = self._training_input_history
for name, output_history in self._training_data.items():
surrogate = self._get_surrogate(name)
if surrogate is not None:
surrogate.train(training_input_history, output_history)
self._new_train_data = False
inputs = []
for i, name in enumerate(self.surrogate_input_names()):
val = self.get(name)
cval = self._const_inputs.get(i, _missing)
if cval is _missing:
inputs.append(val)
elif val != cval:
self.raise_exception("ERROR: training input '%s' was a"
" constant value of (%s) but the value"
" has changed to (%s)." %
(name, cval, val), ValueError)
for name in self._training_data:
surrogate = self._get_surrogate(name)
# copy output to boundary
if surrogate is None:
self._set_output(name, self.model.get(name))
else:
self._set_output(name, surrogate.predict(inputs))
def execute(self):
"""Perform the iteration."""
self._check_config()
nvar = len(self.get_parameters().values())
history = zeros([self.max_iteration, nvar])
delta = zeros(nvar)
# Get and save the intial value of the input parameters
val0 = zeros(nvar)
for i, val in enumerate(self.get_parameters().values()):
val0[i] = val.evaluate(self.parent)
# perform an initial run
self.run_iteration()
self.current_iteration = 0
for i, val in enumerate(self.get_eq_constraints().values()):
term = val.evaluate(self.parent)
history[0, i] = term[0] - term[1]
if self.norm_order == 'Infinity':
order = float('inf')
else:
order = 2
unconverged = True
while unconverged:
if self._stop:
self.raise_exception('Stop requested', RunStopped)
# check max iteration
if self.current_iteration >= self.max_iteration - 1:
self.history = history[:self.current_iteration + 1, :]
self.raise_exception('Max iterations exceeded without ' + \
'convergence.', RuntimeError)
# Pass output to input
val0 += history[self.current_iteration, :]
self.set_parameters(val0)
# run the workflow
self.run_iteration()
if self.recorders:
# Write out some relevant information to the first recorder
case_input = []
for target, param in self.get_parameters().iteritems():
case_input.append([target[0], param.evaluate()])
if self.printvars:
case_output = [
(name, ExprEvaluator(name,
scope=self.parent).evaluate())
for name in self.printvars
]
else:
case_output = []
case = Case(case_input, case_output, parent_uuid=self._case_id)
self.recorders[0].record(case)
self.current_iteration += 1
# check convergence
for i, val in enumerate(self.get_eq_constraints().values()):
term = val.evaluate(self.parent)
delta[i] = term[0] - term[1]
history[self.current_iteration] = delta
if norm(delta, order) < self.tolerance:
break
# relative tolerance -- problematic around 0
#if abs( (val1-val0)/val0 ) < self.tolerance:
# break
self.history = history[:self.current_iteration + 1, :]
def execute(self):
"""If the training flag is set, train the metamodel. Otherwise,
predict outputs.
"""
if self._train:
if self.model is None:
self.raise_exception("MetaModel object must have a model!",
RuntimeError)
try:
inputs = self.update_model_inputs()
#print '%s training with inputs: %s' % (self.get_pathname(), inputs)
self.model.run(force=True)
except Exception as err:
self._failed_training_msgs.append(str(err))
else: #if no exceptions are generated, save the data
self._training_input_history.append(inputs)
self.update_outputs_from_model()
case_outputs = []
for name, tup in self._surrogate_info.items():
surrogate, output_history = tup
case_outputs.append(('.'.join([self.name,
name]), output_history[-1]))
# save the case, making sure to add out name to the local input name since
# this Case is scoped to our parent Assembly
case_inputs = [
('.'.join([self.name, name]), val)
for name, val in zip(self._surrogate_input_names, inputs)
]
if self.recorder:
self.recorder.record(
Case(inputs=case_inputs, outputs=case_outputs))
self._train = False
else:
#print '%s predicting' % self.get_pathname()
if self._new_train_data:
if len(self._training_input_history) < 2:
self.raise_exception(
"ERROR: need at least 2 training points!",
RuntimeError)
# figure out if we have any constant training inputs
tcases = self._training_input_history
in_hist = tcases[0][:]
# start off assuming every input is constant
idxlist = range(len(in_hist))
self._const_inputs = dict(zip(idxlist, in_hist))
for i in idxlist:
val = in_hist[i]
for case in range(1, len(tcases)):
if val != tcases[case][i]:
del self._const_inputs[i]
break
if len(self._const_inputs) == len(in_hist):
self.raise_exception(
"ERROR: all training inputs are constant.")
elif len(self._const_inputs) > 0:
# some inputs are constant, so we have to remove them from the training set
training_input_history = []
for inputs in self._training_input_history:
training_input_history.append([
val for i, val in enumerate(inputs)
if i not in self._const_inputs
])
else:
training_input_history = self._training_input_history
for name, tup in self._surrogate_info.items():
surrogate, output_history = tup
surrogate.train(training_input_history, output_history)
self._new_train_data = False
inputs = []
for i, name in enumerate(self._surrogate_input_names):
val = getattr(self, name)
cval = self._const_inputs.get(i, _missing)
if cval is _missing:
inputs.append(val)
elif val != cval:
self.raise_exception(
"ERROR: training input '%s' was a constant value of (%s) but the value has changed to (%s)."
% (name, cval, val), ValueError)
for name, tup in self._surrogate_info.items():
surrogate = tup[0]
# copy output to boudary
setattr(self, name, surrogate.predict(inputs))
