def test_basics(self):
# Try a few different values of order and form
# Forward with order 1
self.model.driver.distribution_generator = FiniteDifferenceGenerator(
self.model.driver)
self.results = ListCaseRecorder()
self.model.driver.recorders = [self.results]
self.order = 1
self.model.driver.distribution_generator.form = "FORWARD"
self.model.driver.distribution_generator.order = self.order
self.model.run()
self.verify_results()
# reset driven component values
self.model.driven.x0 = self.model.driven.x1 = self.model.driven.x2 = self.model.driven.x3 = 1.0
# Backward with order 2
self.model.driver.distribution_generator = FiniteDifferenceGenerator(
self.model.driver)
self.results = ListCaseRecorder()
self.model.driver.recorders = [self.results]
self.order = 2
self.model.driver.distribution_generator.form = "BACKWARD"
self.model.driver.distribution_generator.order = self.order
self.model.run()
self.verify_results()
# reset driven component values
self.model.driven.x0 = self.model.driven.x1 = self.model.driven.x2 = self.model.driven.x3 = 1.0
# Central with order 2
self.model.driver.distribution_generator = FiniteDifferenceGenerator(
self.model.driver)
self.results = ListCaseRecorder()
self.model.driver.recorders = [self.results]
self.order = 2
self.model.driver.distribution_generator.form = "CENTRAL"
self.model.driver.distribution_generator.order = self.order
self.model.run()
self.verify_results()
# reset driven component values
self.model.driven.x0 = self.model.driven.x1 = self.model.driven.x2 = self.model.driven.x3 = 1.0
# Central with order 3
self.model.driver.distribution_generator = FiniteDifferenceGenerator(
self.model.driver)
self.results = ListCaseRecorder()
self.model.driver.recorders = [self.results]
self.order = 3
self.model.driver.distribution_generator.form = "CENTRAL"
self.model.driver.distribution_generator.order = self.order
self.model.run()
self.verify_results()
def test_array_parameter(self):
self.top.driver.add_objective('comp.result')
self.top.driver.add_parameter('comp.x')
self.top.driver.add_constraint('comp.g <= 0')
self.top.driver.recorders = [ListCaseRecorder()]
self.top.driver.printvars = ['comp.opt_objective']
self.top.run()
# pylint: disable-msg=E1101
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_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.recorders = [ListCaseRecorder()]
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.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.result,
end_case.get_output('_pseudo_0.out0'))
def configure(self):
self.add('paraboloid', Paraboloid())
self.add('driver', DOEdriver())
self.driver.log_level = logging.INFO
# Configure the generator.
self.driver.DOEgenerator = MonteCarlo()
self.driver.DOEgenerator.num_samples = 5000
self.driver.DOEgenerator.dist_types = {
'Default':random.uniform, 'y':random.standard_normal}
self.driver.DOEgenerator.dist_args = {'Default':[0, 1], 'y':[]}
self.driver.DOEgenerator.parameters = ['x', 'y']
# Configure driver parameters.
self.driver.add_parameter('paraboloid.x', low=0, high=1)
self.driver.add_parameter('paraboloid.y', low=0, high=1)
#tell the DOEdriver to also record f_xy.
self.driver.add_response('paraboloid.f_xy')
#Simple recorder which stores the cases in memory.
self.recorders = [ListCaseRecorder(),]
self.driver.workflow.add('paraboloid')
def configure(self):
""" Configure driver and its workflow. """
super(Assembly, self).configure()
## Add some components
self.add('omnivorRun', OmnivorRun())
## Add an optimizer: COBYLAdriver, CONMINdriver, NEWSUMTdriver, SLSQPdriver, Genetic
self.add('driver', COBYLAdriver())
self.driver.workflow.add('omnivorRun')
## The parameters of the optimization
self.driver.add_parameter('omnivorRun.x', low=0, high=5, start=0.1)
self.driver.add_objective('omnivorRun.CP')
self.driver.add_constraint('abs(omnivorRun.CT-0.6) <= 0.001')
## This recorder will create a list of cases
self.driver.recorders = [ListCaseRecorder()]
## These variables will be recorded
self.driver.printvars = ['omnivorRun.x','omnivorRun.CT','omnivorRun.CP']
## Some optimizer options
self.driver.itmax = 100
self.driver.fdch = 0.00001
self.driver.fdchm = 0.000001
self.driver.ctlmin = 0.001
self.driver.delfun = 0.0001
def test_opt1(self):
# Run with scalar parameters, scalar constraints, and OpenMDAO gradient.
self.top.driver.add_objective('10*comp.result')
# pylint: disable-msg=C0301
map(self.top.driver.add_parameter,
['comp.x[0]', 'comp.x[1]', 'comp.x[2]', 'comp.x[3]'])
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.driver.iprint = 0
self.top.run()
# pylint: disable-msg=E1101
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.01)
assert_rel_error(self, 1 + self.top.comp.opt_design_vars[0],
1 + self.top.comp.x[0], 0.05)
assert_rel_error(self, self.top.comp.opt_design_vars[1],
self.top.comp.x[1], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[2],
self.top.comp.x[2], 0.06)
assert_rel_error(self, self.top.comp.opt_design_vars[3],
self.top.comp.x[3], 0.05)
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_scid(self):
# Record tree of cases via SimpleCaseIterDriver.
top = Assembly()
top.recorders = [ListCaseRecorder()]
top.add('driver2', SCIDriver(3, 'comp2'))
top.add('comp2', CaseComponent())
top.driver2.workflow.add('comp2')
top.add('driver1', SCIDriver(2, 'comp1'))
top.add('comp1', CaseComponent())
top.driver1.workflow.add(['comp1', 'driver2'])
top.driver.workflow.add('driver1')
top.run()
print
print 'Forest:'
roots = CaseTreeNode.sort(top.recorders[0].get_iterator())
for root in roots:
root.dump(1)
print
print 'Iternames:'
for root in roots:
for name in root.iternames():
print ' ', name
expected = [
'1', '1-1.1', '1-1.1-2.1', '1-1.1-2.2', '1-1.1-2.3', '1-1.2',
'1-1.2-2.1', '1-1.2-2.2', '1-1.2-2.3'
]
for i, name in enumerate(roots[0].iternames()):
self.assertEqual(name, expected[i])
def test_super_simple_backward(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]
model.driver.distribution_generator.form = "BACKWARD"
model.driver.distribution_generator.order = 2
model.run()
self.assertAlmostEqual( results.cases[0][ 'driven.x' ], 1.0, places = 6 )
self.assertAlmostEqual( results.cases[0][ 'driven.y' ], 2.0, places = 6 )
self.assertAlmostEqual( results.cases[1][ 'driven.x' ], 0.8, places = 6 )
self.assertAlmostEqual( results.cases[1][ 'driven.y' ], 1.6, places = 6 )
self.assertAlmostEqual( results.cases[2][ 'driven.x' ], 0.9, places = 6 )
self.assertAlmostEqual( results.cases[2][ 'driven.y' ], 1.8, places = 6 )
def run_cases(self, sequential, forced_errors=False, retry=True):
""" Evaluate cases, either sequentially or across multiple servers. """
self.model.driver.sequential = sequential
if not sequential:
# Try to ensure more than one worker is used.
self.model.driven.sleep = 0.2
self.model.driver.iterator = ListCaseIterator(self.cases)
results = ListCaseRecorder()
self.model.driver.recorders = [results]
self.model.driver.printvars = ['driven.extra']
self.model.driver.error_policy = 'RETRY' if retry else 'ABORT'
if retry:
self.model.run()
self.assertEqual(len(results), len(self.cases))
self.verify_results(forced_errors)
else:
try:
self.model.run()
except Exception as err:
err = replace_uuid(str(err))
startmsg = 'driver: Run aborted: Traceback '
endmsg = 'driven (UUID.4-1): Forced error'
self.assertEqual(str(err)[:len(startmsg)], startmsg)
self.assertEqual(str(err)[-len(endmsg):], endmsg)
else:
self.fail("Exception expected")
def test_nooutput(self):
logging.debug('')
logging.debug('test_nooutput')
# Create cases with missing output 'dc.sum_z'.
cases = []
for i in range(2):
inputs = [('driven.x', numpy_random.normal(size=4)),
('driven.y', numpy_random.normal(size=10))]
outputs = [('driven.rosen_suzuki', None), ('driven.sum_z', 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.driver.error_policy = 'RETRY'
self.model.run()
self.assertEqual(len(results), len(cases))
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_array(self):
# Run with array parameter, array constraint.
self.top.driver.add_objective('comp.result')
self.top.driver.add_parameter('comp.x')
self.top.driver.add_constraint('comp.g < 0')
self.top.recorders = [ListCaseRecorder()]
self.top.run()
# pylint: disable=E1101
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.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.result,
end_case.get_output('_pseudo_0.out0'))
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 = MonteCarlo()
self.driver.DOEgenerator.num_samples = 5000
self.driver.DOEgenerator.dist_types = {
'Default': random.uniform,
'y': random.standard_normal
}
self.driver.DOEgenerator.dist_args = {'Default': [0, 1], 'y': []}
self.driver.DOEgenerator.parameters = ['x', 'y']
#DOEdriver will automatically record the values of any parameters for each case
self.driver.add_parameter('paraboloid.x', low=0, high=1)
self.driver.add_parameter('paraboloid.y', low=0, high=1)
#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_opt1(self):
# Run with scalar parameters, scalar constraints.
self.top.driver.add_objective('comp.result')
map(self.top.driver.add_parameter,
['comp.x[0]', 'comp.x[1]', 'comp.x[2]', 'comp.x[3]'])
# pylint: disable=C0301
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.recorders = [ListCaseRecorder()]
self.top.run()
# pylint: disable=E1101
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.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.result,
end_case.get_output('_pseudo_0.out0'))
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 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 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', 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_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.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_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_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.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_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_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 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_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)]))