def test_dumprecorder(self):
sout1 = StringIO.StringIO()
sout2 = StringIO.StringIO()
self.top.driver.recorders = [
DumpCaseRecorder(sout1),
DumpCaseRecorder(sout2)
]
self.top.run()
expected = [
'Case: case8',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' inputs:',
' comp1.x: 8',
' comp1.y: 16',
' outputs:',
' comp1.z: 24.0',
' comp2.z: 25.0',
]
for sout in [sout1, sout2]:
lines = sout.getvalue().split('\n')
index = lines.index('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])
def test_nested_assy_match_wildcard(self):
self.top.add('comp1', Basic_Component())
self.top.add('nested', Nest_Me())
self.top.driver.workflow.add('nested')
self.top.nested.add('doublenest', Nest_Me())
self.top.nested.driver.workflow.add('doublenest')
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.recording_options.includes = ['*comp1.*']
self.top.run()
expected = """\
Constants:
comp1.directory:
comp1.force_fd: False
comp1.missing_deriv_policy: error
comp1.x1: 0.0
nested.comp1.directory:
nested.comp1.force_fd: False
nested.comp1.missing_deriv_policy: error
nested.comp1.x1: 0.0
nested.doublenest.comp1.directory:
nested.doublenest.comp1.force_fd: False
nested.doublenest.comp1.missing_deriv_policy: error
nested.doublenest.comp1.x1: 0.0
Case:
uuid: f08eea75-8004-11e4-8003-20c9d0478eff
timestamp: 1418171943.211238
parent_uuid: f08d0147-8004-11e4-8002-20c9d0478eff
outputs:
nested.doublenest.comp1.derivative_exec_count: 0
nested.doublenest.comp1.exec_count: 1
nested.doublenest.comp1.itername: 1-nested.1-doublenest.1-comp1
nested.doublenest.comp1.y1: 1.0
Case:
uuid: f08d0147-8004-11e4-8002-20c9d0478eff
timestamp: 1418171943.211432
parent_uuid: f08aa2b8-8004-11e4-8001-20c9d0478eff
outputs:
nested.comp1.derivative_exec_count: 0
nested.comp1.exec_count: 1
nested.comp1.itername: 1-nested.1-comp1
nested.comp1.y1: 1.0
"""
expected = expected.split('\n')
# print sout.getvalue()
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
line = line.rstrip()
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
elif template.startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
elif template.startswith(' parent_uuid:'):
self.assertTrue(line.startswith(' parent_uuid:'))
else:
self.assertEqual(line, template)
def test_nested_assy_match_wildcard(self):
self.top.add('comp1', Basic_Component())
self.top.add('nested', Nest_Me())
self.top.driver.workflow.add('nested')
self.top.nested.add('doublenest', Nest_Me())
self.top.nested.driver.workflow.add('doublenest')
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.recording_options.includes = ['*comp1.*']
self.top.run()
expected = """\
Constants:
comp1.directory:
comp1.force_fd: False
comp1.missing_deriv_policy: error
comp1.x1: 0.0
nested.comp1.directory:
nested.comp1.force_fd: False
nested.comp1.missing_deriv_policy: error
nested.comp1.x1: 0.0
nested.doublenest.comp1.directory:
nested.doublenest.comp1.force_fd: False
nested.doublenest.comp1.missing_deriv_policy: error
nested.doublenest.comp1.x1: 0.0
Case:
uuid: 84c2195c-e043-11e3-8008-005056000100
timestamp: 1400606634.601406
parent_uuid: 84c1b666-e043-11e3-8007-005056000100
outputs:
nested.doublenest.comp1.derivative_exec_count: 0
nested.doublenest.comp1.exec_count: 1
nested.doublenest.comp1.itername: 1-nested.1-doublenest.1-comp1
nested.doublenest.comp1.y1: 1.0
Case:
uuid: 84c1b666-e043-11e3-8007-005056000100
timestamp: 1400606634.601622
parent_uuid: 84c1b0f8-e043-11e3-8006-005056000100
outputs:
nested.comp1.derivative_exec_count: 0
nested.comp1.exec_count: 1
nested.comp1.itername: 1-nested.1-comp1
nested.comp1.y1: 1.0
"""
expected = expected.split('\n')
# print sout.getvalue()
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
line = line.rstrip()
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
elif template.startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
elif template.startswith(' parent_uuid:'):
self.assertTrue(line.startswith(' parent_uuid:'))
else:
self.assertEqual(line, template)
def test_multiple_objectives(self):
sout = StringIO.StringIO()
self.top.add('driver', SensitivityDriver())
self.top.driver.workflow.add(['comp1', 'comp2'])
self.top.driver.add_parameter(['comp1.x'], low=-100, high=100)
self.top.driver.add_objective('comp1.z')
self.top.driver.add_objective('comp2.z')
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.run()
expected = [
'Case: ',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' timestamp: 1383239074.309192',
' inputs:',
' comp1.x: [0.0]',
' outputs:',
' Objective_0: 0.0',
' Objective_1: 1.0',
' driver.workflow.itername: 1',
]
lines = sout.getvalue().split('\n')
for i in range(len(expected)):
if expected[i].startswith(' uuid:'):
self.assertTrue(lines[i].startswith(' uuid:'))
elif expected[i].startswith(' timestamp:'):
self.assertTrue(lines[i].startswith(' timestamp:'))
else:
self.assertEqual(lines[i], expected[i])
def test_more_datatypes(self):
self.top.add('comp1', Complex_Comp())
self.top.driver.workflow.add('comp1')
sout = StringIO.StringIO()
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.driver.printvars = ['*']
self.top.run()
expected = [
'Case: 1',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' inputs:',
' comp1.directory: ',
' comp1.force_execute: False',
' comp1.list_str: []',
' driver.directory: ',
' driver.force_execute: True',
" driver.printvars: ['*']",
' outputs:',
' comp1.string: Testing',
]
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
else:
self.assertEqual(line, template)
def test_options_with_includes_excludes(self):
""" verify options with includes and excludes (excludes are processed after includes):
save_problem_formulation = True
includes = ['comp1']
excludes = ['*directory', '*force_fd', '*missing_deriv_policy']
"""
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.recording_options.includes = ['comp1*']
self.top.recording_options.excludes = [
'*directory', '*force_fd', '*missing_deriv_policy'
]
self.top.run()
expected = """\
Constants:
comp1.y: 0.0
Case:
uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe
timestamp: 1383239074.309192
inputs:
comp1.x: 0.0
outputs:
Objective(comp1.z): 0.0
Objective(comp2.z): 1.0
comp1.derivative_exec_count: 0
comp1.exec_count: 1
comp1.itername: 1-comp1
comp1.z: 0.0
"""
# print sout.getvalue()
self.verify_case_dump(expected, sout)
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.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_includes_only(self):
""" verify options with includes but not problem formulation:
save_problem_formulation = False
includes = ['comp2*']
excludes = []
"""
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.recording_options.save_problem_formulation = False
self.top.recording_options.includes = ['comp2*']
self.top.run()
expected = """\
Constants:
comp2.directory:
comp2.force_fd: False
comp2.missing_deriv_policy: error
Case:
uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe
timestamp: 1383239074.309192
outputs:
comp2.derivative_exec_count: 0
comp2.exec_count: 1
comp2.itername: 1-comp2
comp2.z: 1.0
"""
# print sout.getvalue()
self.verify_case_dump(expected, sout)
def test_problem_formulation_only(self):
""" verify options with no includes:
save_problem_formulation = True
includes = []
excludes = []
"""
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.recording_options.save_problem_formulation = True
self.top.recording_options.includes = []
self.top.run()
expected = """\
Constants:
Case:
uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe
timestamp: 1383239074.309192
inputs:
comp1.x: 0.0
outputs:
Objective(comp1.z): 0.0
Objective(comp2.z): 1.0
"""
# print sout.getvalue()
self.verify_case_dump(expected, sout)
def configure(self):
self.add('d', Dummy())
self.add('driver', NeighborhoodDOEdriver())
self.driver.DOEgenerator = FullFactorial(2)
self.driver.recorders = [DumpCaseRecorder()]
self.driver.add_parameter('d.x', low=0, high=10)
self.driver.case_outputs = ['d.y', 'd.bad', 'd.z']
def test_nested_assy_match_wildcard(self):
self.top.add('comp1', Basic_Component())
self.top.add('nested', Nest_Me())
self.top.driver.workflow.add('nested')
self.top.nested.add('doublenest', Nest_Me())
self.top.nested.driver.workflow.add('doublenest')
sout = StringIO.StringIO()
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.driver.printvars = ['*comp1*']
self.top.run()
expected = [
'Case: 1',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' inputs:',
' nested.comp1.directory: ',
' nested.comp1.force_execute: False',
' nested.comp1.x1: 0.0',
' nested.doublenest.comp1.directory: ',
' nested.doublenest.comp1.force_execute: False',
' nested.doublenest.comp1.x1: 0.0',
' outputs:',
" nested.comp1.y1: 1.0",
" nested.doublenest.comp1.y1: 1.0",
]
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
else:
self.assertEqual(line, template)
def test_inoutDB(self):
"""This test runs some cases, puts them in a DB using a DBCaseRecorder,
then runs the model again using the same cases, pulled out of the DB
by a DBCaseIterator. Finally the cases are dumped to a string after
being run for the second time.
"""
self.top.driver.recorders = [DBCaseRecorder()]
self.top.run()
# Gui pane stuff
attrs = self.top.driver.recorders[0].get_attributes()
self.assertTrue("Inputs" in attrs.keys())
self.assertTrue({
'name':
'dbfile',
'id':
'dbfile',
'type':
'str',
'connected':
'',
'value':
':memory:',
'desc':
'Name of the database file to be recorded. Default ' +
'is ":memory:", which writes the database to memory.'
} in attrs['Inputs'])
# now use the DB 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',
' inputs:',
" comp1.a_dict: {'a': 'b'}",
" comp1.a_list: ['a', 'b']",
' comp1.x: 8',
' comp1.y: 16',
' outputs:',
' comp1.z: 24.0',
' comp2.z: 25.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_bad_recorder(self):
try:
self.top.driver.recorders = DumpCaseRecorder()
except Exception as err:
self.assertTrue(str(err).startswith("The 'recorders' trait of a SimpleCaseIterDriver"))
self.assertTrue(str(err).endswith(" was specified."))
else:
self.fail("Exception expected")
def test_more_datatypes(self):
self.top.add('comp1', Complex_Comp())
self.top.driver.workflow.add('comp1')
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.run()
expected = """\
Constants:
comp1.directory:
comp1.force_fd: False
comp1.list_str: []
comp1.missing_deriv_policy: error
directory:
driver.directory:
driver.force_fd: False
driver.gradient_options.atol: 1e-09
driver.gradient_options.derivative_direction: auto
driver.gradient_options.directional_fd: False
driver.gradient_options.fd_blocks: []
driver.gradient_options.fd_form: forward
driver.gradient_options.fd_step: 1e-06
driver.gradient_options.fd_step_type: absolute
driver.gradient_options.force_fd: False
driver.gradient_options.lin_solver: scipy_gmres
driver.gradient_options.maxiter: 100
driver.gradient_options.rtol: 1e-09
force_fd: False
missing_deriv_policy: assume_zero
recording_options.excludes: []
recording_options.includes: ['*']
recording_options.save_problem_formulation: True
Case:
uuid: 53ffa7b3-8005-11e4-8001-20c9d0478eff
timestamp: 1418172110.042416
outputs:
comp1.derivative_exec_count: 0
comp1.exec_count: 1
comp1.itername: 1-comp1
comp1.string: Testing
driver.workflow.itername: 1
"""
expected = expected.split('\n')
# print sout.getvalue()
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
line = line.rstrip()
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
elif template.startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
elif 'gradient_options' in template:
self.assertEqual(line.split('<')[0], template.split('<')[0])
else:
self.assertEqual(line, template)
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 test_inoutCSV_delimiter(self):
#Repeat test above using semicolon delimiter and ' as quote char.
self.top.driver.recorders = [CSVCaseRecorder(filename=self.filename, delimiter=';', \
quotechar="'")]
self.top.run()
attrs = self.top.driver.recorders[0].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 output.'} in attrs['Inputs'])
self.assertTrue({'name': 'append',
'type': 'bool',
'connected': '',
'value': 'False',
'desc': 'Set to True to append to the existing CSV file.'} in attrs['Inputs'])
self.assertTrue({'name': 'delimiter',
'type': 'str',
'connected': '',
'value': ';',
'desc': 'CSV delimiter. Default is ",".'} in attrs['Inputs'])
# now use the DB 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',
' inputs:',
' comp1.x: 8.1',
' comp1.x_array[1]: 99.88',
' comp1.y: 16.1',
' outputs:',
" comp1.a_array[2]: 5.5",
" comp1.a_string: Hello',;','",
' comp1.z: 24.2',
' comp2.z: 25.2',
]
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_default_options(self):
""" verify default options:
save_problem_formulation = True
includes = ['*']
excludes = []
"""
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.run()
expected = """\
Constants:
comp1.directory:
comp1.force_fd: False
comp1.missing_deriv_policy: error
comp1.y: 0.0
comp2.directory:
comp2.force_fd: False
comp2.missing_deriv_policy: error
directory:
driver.directory:
driver.force_fd: False
driver.gradient_options.derivative_direction: auto
driver.gradient_options.directional_fd: False
driver.gradient_options.fd_blocks: []
driver.gradient_options.fd_form: forward
driver.gradient_options.fd_step: 1e-06
driver.gradient_options.fd_step_type: absolute
driver.gradient_options.force_fd: False
driver.gradient_options.gmres_maxiter: 100
driver.gradient_options.gmres_tolerance: 1e-09
force_fd: False
missing_deriv_policy: assume_zero
recording_options.excludes: []
recording_options.includes: ['*']
recording_options.save_problem_formulation: True
Case:
uuid: 578b2d91-5b94-11e4-8001-08002764016b
timestamp: 1414165341.001852
inputs:
comp1.x: 0.0
outputs:
Objective(comp1.z): 0.0
Objective(comp2.z): 1.0
comp1.derivative_exec_count: 0
comp1.exec_count: 1
comp1.itername: 1-comp1
comp1.z: 0.0
comp2.derivative_exec_count: 0
comp2.exec_count: 1
comp2.itername: 1-comp2
comp2.z: 1.0
driver.workflow.itername: 1
"""
# print sout.getvalue()
self.verify_case_dump(expected, sout)
def test_exclude_pseudocomps(self):
# Pseudocomp comes from unit conversion
self.top.add('comp1', Basic_Component())
self.top.driver.workflow.add('comp1')
self.top.add('comp2', Basic_Component())
self.top.driver.workflow.add('comp2')
self.top.connect('comp1.y1', 'comp2.x1')
sout = StringIO.StringIO()
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.driver.printvars = ['*']
self.top.run()
expected = [
'Case: ',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' timestamp: 1383239074.309192',
' inputs:',
' comp1.directory: ',
' comp1.force_execute: False',
' comp1.force_fd: False',
' comp1.missing_deriv_policy: error',
' comp1.x1: 0.0',
' comp2.directory: ',
' comp2.force_execute: False',
' comp2.force_fd: False',
' comp2.missing_deriv_policy: error',
' comp2.x1: 100.0',
' driver.directory: ',
' driver.force_execute: True',
' driver.force_fd: False',
' driver.gradient_options: <>',
" driver.printvars: ['*']",
' outputs:',
' comp1.derivative_exec_count: 0',
' comp1.exec_count: 1',
' comp1.itername: 1-1',
' comp1.y1: 1.0',
' comp2.derivative_exec_count: 0',
' comp2.exec_count: 1',
' comp2.itername: 1-2',
' comp2.y1: 101.0',
' driver.derivative_exec_count: 0',
' driver.exec_count: 1',
' driver.itername: ',
' driver.workflow.itername: 1',
]
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
elif template.startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
elif 'gradient_options' in template:
self.assertEqual(line.split('<')[0], template.split('<')[0])
else:
self.assertEqual(line, template)
def __init__(self):
super(Analysis, self).__init__(self)
self.add('d', Dummy())
self.add('driver', DOEdriver())
self.driver.DOEgenerator = FullFactorial(2)
self.driver.recorders = [DumpCaseRecorder()]
self.driver.add_parameter('d.x', low=0, high=10)
self.driver.case_outputs = ['d.y', 'd.bad', 'd.z']
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 test_workflow_itername(self):
# top
# comp1
# driverA
# comp1
# comp2
# driverB
# comp2
# subassy
# comp3
top = Assembly()
top.add('comp1', Basic_Component())
top.add('driverA', Run_N(4))
top.add('comp2', Basic_Component())
top.add('driverB', Run_N(3))
sub = top.add('subassy', Assembly())
sub.add('comp3', Basic_Component())
sub.driver.workflow.add('comp3')
top.driver.workflow.add(('comp1', 'driverA', 'driverB'))
sout = StringIO.StringIO()
top.recorders = [DumpCaseRecorder(sout)]
top.driverA.workflow.add(('comp1', 'comp2'))
top.driverB.workflow.add(('comp2', 'subassy'))
top.run()
expected = [
'driverA.workflow.itername: 1-driverA.1',
'driverA.workflow.itername: 1-driverA.2',
'driverA.workflow.itername: 1-driverA.3',
'driverA.workflow.itername: 1-driverA.4',
'driverA.workflow.itername: 1-driverA.5',
'subassy.driver.workflow.itername: 1-driverB.1-subassy.1',
'driverB.workflow.itername: 1-driverB.1',
'subassy.driver.workflow.itername: 1-driverB.2-subassy.1',
'driverB.workflow.itername: 1-driverB.2',
'subassy.driver.workflow.itername: 1-driverB.3-subassy.1',
'driverB.workflow.itername: 1-driverB.3',
'subassy.driver.workflow.itername: 1-driverB.4-subassy.1',
'driverB.workflow.itername: 1-driverB.4',
'driver.workflow.itername: 1'
]
lines = [
l.strip() for l in sout.getvalue().split('\n')
if 'workflow.itername' in l
]
for i, line in enumerate(lines):
self.assertEqual(line, expected[i])
def test_nested_assy_match_wildcard(self):
self.top.add('comp1', Basic_Component())
self.top.add('nested', Nest_Me())
self.top.driver.workflow.add('nested')
self.top.nested.add('doublenest', Nest_Me())
self.top.nested.driver.workflow.add('doublenest')
sout = StringIO.StringIO()
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.driver.printvars = ['*comp1*']
self.top.run()
expected = [
'Case: ',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' timestamp: 1383239074.309192',
' inputs:',
' nested.comp1.directory: ',
' nested.comp1.force_execute: False',
' nested.comp1.force_fd: False',
' nested.comp1.missing_deriv_policy: error',
' nested.comp1.x1: 0.0',
' nested.doublenest.comp1.directory: ',
' nested.doublenest.comp1.force_execute: False',
' nested.doublenest.comp1.force_fd: False',
' nested.doublenest.comp1.missing_deriv_policy: error',
' nested.doublenest.comp1.x1: 0.0',
' outputs:',
' driver.workflow.itername: 1',
' nested.comp1.derivative_exec_count: 0',
' nested.comp1.exec_count: 1',
' nested.comp1.itername: 1-1.1-1',
' nested.comp1.y1: 1.0',
' nested.doublenest.comp1.derivative_exec_count: 0',
' nested.doublenest.comp1.exec_count: 1',
' nested.doublenest.comp1.itername: 1-1.1-4.1-1',
' nested.doublenest.comp1.y1: 1.0',
]
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
elif template.startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
else:
self.assertEqual(line, template)
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_more_datatypes(self):
self.top.add('comp1', Complex_Comp())
self.top.driver.workflow.add('comp1')
sout = StringIO.StringIO()
self.top.driver.recorders = [DumpCaseRecorder(sout)]
self.top.driver.printvars = ['*']
self.top.run()
expected = [
'Case: ',
' uuid: ad4c1b76-64fb-11e0-95a8-001e8cf75fe',
' timestamp: 1383239074.309192',
' inputs:',
' comp1.directory: ',
' comp1.force_execute: False',
' comp1.force_fd: False',
' comp1.list_str: []',
' comp1.missing_deriv_policy: error',
' driver.directory: ',
' driver.force_execute: True',
' driver.force_fd: False',
' driver.gradient_options: <>',
" driver.printvars: ['*']",
' outputs:',
' comp1.derivative_exec_count: 0',
' comp1.exec_count: 1',
' comp1.itername: 1-1',
' comp1.string: Testing',
' driver.derivative_exec_count: 0',
' driver.exec_count: 1',
' driver.itername: ',
' driver.workflow.itername: 1',
]
lines = sout.getvalue().split('\n')
for line, template in zip(lines, expected):
if template.startswith(' uuid:'):
self.assertTrue(line.startswith(' uuid:'))
elif template.startswith(' timestamp:'):
self.assertTrue(line.startswith(' timestamp:'))
elif 'gradient_options' in template:
self.assertEqual(line.split('<')[0], template.split('<')[0])
else:
self.assertEqual(line, template)
def configure(self):
""" Configure a simple DOE to set start points for CONMIN. """
self.add('gp_fun', GoldsteinPrice())
conmin = self.add('conmin', CONMINdriver())
conmin.workflow.add('gp_fun')
conmin.add_parameter('gp_fun.x1')
conmin.add_parameter('gp_fun.x2')
conmin.add_objective('gp_fun.f')
doe = self.add('driver', DOEdriver())
doe.workflow.add('conmin')
doe.add_parameter('gp_fun.x1', low=-1.5, high=1.5, start=1)
doe.add_parameter('gp_fun.x2', low=-1.5, high=1.5, start=1)
doe.DOEgenerator = FullFactorial(5)
doe.add_responses(
['gp_fun.f', 'gp_fun.x1', 'gp_fun.x2', 'gp_fun.exec_count'])
self.recorders = [CSVCaseRecorder(), DumpCaseRecorder()]
def test_inoutCSV(self):
#This test runs some cases, puts them in a CSV file using a CSVCaseRecorder,
#then runs the model again using the same cases, pulled out of the CSV file
#by a CSVCaseIterator. Finally the cases are dumped to a string after
#being run for the second time.
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',
' inputs:',
' comp1.b_bool: True',
' comp1.x: 8.1',
' comp1.x_array[1]: 99.88',
' comp1.y: 16.1',
' outputs:',
#" comp1.a_list: [1, 'one', 1.0]",
" comp1.a_array[2]: 5.5",
" comp1.a_string: Hello',;','",
' comp1.z: 24.2',
' comp2.z: 25.2',
]
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_options_with_excludes(self):
""" verify options with excludes:
save_problem_formulation = True
includes = ['*']
excludes = ['*directory', '*force_fd', '*missing_deriv_policy', '*gradient_options*']
"""
sout = StringIO.StringIO()
self.top.recorders = [DumpCaseRecorder(sout)]
self.top.recording_options.excludes = [
'*directory', '*force_fd', '*missing_deriv_policy',
'*gradient_options*'
]
self.top.run()
expected = """\
Constants:
comp1.y: 0.0
recording_options.excludes: ['*directory', '*force_fd', '*missing_deriv_policy', '*gradient_options*']
recording_options.includes: ['*']
recording_options.save_problem_formulation: True
Case:
uuid: 80dd42d1-5b94-11e4-8004-08002764016b
timestamp: 1414165410.332183
inputs:
comp1.x: 0.0
outputs:
Objective(comp1.z): 0.0
Objective(comp2.z): 1.0
comp1.derivative_exec_count: 0
comp1.exec_count: 1
comp1.itername: 1-comp1
comp1.z: 0.0
comp2.derivative_exec_count: 0
comp2.exec_count: 1
comp2.itername: 1-comp2
comp2.z: 1.0
driver.workflow.itername: 1
"""
# print sout.getvalue()
self.verify_case_dump(expected, sout)
def test_inoutCSV_delimiter(self):
#Repeat test above using semicolon delimiter and ' as quote char.
self.top.driver.recorders = [CSVCaseRecorder(filename=self.filename, delimiter=';', \
quotechar="'")]
self.top.run()
# now use the DB 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',
' inputs:',
' comp1.x: 8.1',
' comp1.x_array[1]: 99.88',
' comp1.y: 16.1',
' outputs:',
" comp1.a_array[2]: 5.5",
" comp1.a_string: Hello',;','",
' comp1.z: 24.2',
' comp2.z: 25.2',
]
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_inoutDB(self):
"""This test runs some cases, puts them in a DB using a DBCaseRecorder,
then runs the model again using the same cases, pulled out of the DB
by a DBCaseIterator. Finally the cases are dumped to a string after
being run for the second time.
"""
self.top.driver.recorders = [DBCaseRecorder()]
self.top.run()
# now use the DB 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',
' inputs:',
' comp1.x: 8',
' comp1.y: 16',
' outputs:',
' comp1.z: 24.0',
' comp2.z: 25.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")
'Major optimality tolerance': 1e-5,
'Function precision': 1e-8}
# ----------------------
# --- Objective ---
tower.driver.add_objective('tower1.mass / 300000')
# ----------------------
# --- Design Variables ---
tower.driver.add_parameter('z_param[1]', low=0.0, high=87.0)
tower.driver.add_parameter('d_param[:-1]', low=3.87, high=20.0)
tower.driver.add_parameter('t_param', low=0.005, high=0.2)
# ----------------------
# --- recorder ---
tower.recorders = [DumpCaseRecorder()]
# ----------------------
# --- Constraints ---
tower.driver.add_constraint('tower1.stress <= 1.0')
tower.driver.add_constraint('tower2.stress <= 1.0')
tower.driver.add_constraint('tower1.global_buckling <= 1.0')
tower.driver.add_constraint('tower2.global_buckling <= 1.0')
tower.driver.add_constraint('tower1.shell_buckling <= 1.0')
tower.driver.add_constraint('tower2.shell_buckling <= 1.0')
tower.driver.add_constraint('tower1.damage <= 1.0')
tower.driver.add_constraint('gc.weldability <= 0.0')
tower.driver.add_constraint('gc.manufacturability <= 0.0')
freq1p = 0.2 # 1P freq in Hz
tower.driver.add_constraint('tower1.f1 >= 1.1*%f' % freq1p)
# ----------------------
