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))