def test_metamodel_feature(self): # create a MetaModelUnStructuredComp, specifying surrogates for the outputs import numpy as np import openmdao.api as om trig = om.MetaModelUnStructuredComp() x_train = np.linspace(0, 10, 20) trig.add_input('x', 0., training_data=x_train) trig.add_output('sin_x', 0., training_data=.5 * np.sin(x_train), surrogate=om.KrigingSurrogate()) trig.add_output('cos_x', 0., training_data=.5 * np.cos(x_train)) trig.options['default_surrogate'] = om.KrigingSurrogate() # add it to a Problem, run and check the predicted values prob = om.Problem() prob.model.add_subsystem('trig', trig) prob.setup() prob['trig.x'] = 2.1 prob.run_model() assert_near_equal(prob['trig.sin_x'], .5 * np.sin(prob['trig.x']), 1e-4) assert_near_equal(prob['trig.cos_x'], .5 * np.cos(prob['trig.x']), 1e-4)
def test_basics(self): # create a metamodel component mm = om.MetaModelUnStructuredComp() mm.add_input('x1', 0.) mm.add_input('x2', 0.) mm.add_output('y1', 0.) mm.add_output('y2', 0., surrogate=om.KrigingSurrogate()) mm.options['default_surrogate'] = om.ResponseSurface() # add metamodel to a problem prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() # check that surrogates were properly assigned surrogate = mm._metadata('y1').get('surrogate') self.assertTrue(isinstance(surrogate, om.ResponseSurface)) surrogate = mm._metadata('y2').get('surrogate') self.assertTrue(isinstance(surrogate, om.KrigingSurrogate)) # populate training data mm.options['train:x1'] = [1.0, 2.0, 3.0] mm.options['train:x2'] = [1.0, 3.0, 4.0] mm.options['train:y1'] = [3.0, 2.0, 1.0] mm.options['train:y2'] = [1.0, 4.0, 7.0] # run problem for provided data point and check prediction prob['mm.x1'] = 2.0 prob['mm.x2'] = 3.0 self.assertTrue(mm.train) # training will occur before 1st run prob.run_model() assert_near_equal(prob['mm.y1'], 2.0, .00001) assert_near_equal(prob['mm.y2'], 4.0, .00001) # run problem for interpolated data point and check prediction prob['mm.x1'] = 2.5 prob['mm.x2'] = 3.5 self.assertFalse(mm.train) # training will not occur before 2nd run prob.run_model() assert_near_equal(prob['mm.y1'], 1.5934, .001) # change default surrogate, re-setup and check that metamodel re-trains mm.options['default_surrogate'] = om.KrigingSurrogate() prob.setup() surrogate = mm._metadata('y1').get('surrogate') self.assertTrue(isinstance(surrogate, om.KrigingSurrogate)) self.assertTrue(mm.train) # training will occur after re-setup
def test_metamodel_feature_vector(self): # Like simple sine example, but with input of length n instead of scalar # The expected behavior is that the output is also of length n, with # each one being an independent prediction. # Its as if you stamped out n copies of metamodel, ran n scalars # through its input, then muxed all those outputs into one contiguous # array but you skip all the n-copies thing and do it all as an array import numpy as np import openmdao.api as om size = 3 # create a vectorized MetaModelUnStructuredComp for sine trig = om.MetaModelUnStructuredComp( vec_size=size, default_surrogate=om.KrigingSurrogate()) trig.add_input('x', np.zeros(size)) trig.add_output('y', np.zeros(size)) # add it to a Problem prob = om.Problem() prob.model.add_subsystem('trig', trig) prob.setup() # provide training data trig.options['train:x'] = np.linspace(0, 10, 20) trig.options['train:y'] = .5 * np.sin(trig.options['train:x']) # train the surrogate and check predicted value prob['trig.x'] = np.array([2.1, 3.2, 4.3]) prob.run_model() assert_near_equal(prob['trig.y'], np.array(.5 * np.sin(prob['trig.x'])), 1e-4)
def setUp(self): self.mm = mm = om.MetaModelUnStructuredComp() filename = os.path.join(self.csv_dir, 'unstructured_data_points.csv') # Training Data x_train1 = np.genfromtxt(filename, delimiter=',', usecols=0) x_train2 = np.genfromtxt(filename, delimiter=',', usecols=1) x_train3 = np.genfromtxt(filename, delimiter=',', usecols=2) y = np.sin(x_train1 * x_train2 * x_train3) # Inputs mm.add_input('input_1', 0., training_data=x_train1) mm.add_input('input_2', 0., training_data=x_train2) mm.add_input('input_3', 0., training_data=x_train3) # Outputs mm.add_output('output_1', 0., training_data=y) # Surrogate Model mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() prob.final_setup()
def test_derivatives(self): mm = om.MetaModelUnStructuredComp() mm.add_input('x', 0.) mm.add_output('f', 0.) mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('p', om.IndepVarComp('x', 0.), promotes_outputs=['x']) prob.model.add_subsystem('mm', mm, promotes_inputs=['x']) prob.setup() mm.options['train:x'] = [0., .25, .5, .75, 1.] mm.options['train:f'] = [1., .75, .5, .25, 0.] prob['x'] = 0.125 prob.run_model() data = prob.check_partials(out_stream=None) Jf = data['mm'][('f', 'x')]['J_fwd'] assert_near_equal(Jf[0][0], -1., 1.e-3) assert_check_partials(data, atol=1e-6, rtol=1e-6) # Complex step prob.setup(force_alloc_complex=True) prob.model.mm.set_check_partial_options(wrt='*', method='cs') data = prob.check_partials(out_stream=None) assert_check_partials(data, atol=1e-11, rtol=1e-11)
def test_metamodel_feature_vector2d(self): # similar to previous example, but processes 3 inputs/outputs at a time import numpy as np import openmdao.api as om size = 3 # create a vectorized MetaModelUnStructuredComp for sine and cosine trig = om.MetaModelUnStructuredComp( vec_size=size, default_surrogate=om.KrigingSurrogate()) trig.add_input('x', np.zeros(size)) trig.add_output('y', np.zeros((size, 2))) # add it to a Problem prob = om.Problem() prob.model.add_subsystem('trig', trig) prob.setup() # provide training data trig.options['train:x'] = np.linspace(0, 10, 20) trig.options['train:y'] = np.column_stack( (.5 * np.sin(trig.options['train:x']), .5 * np.cos(trig.options['train:x']))) # train the surrogate and check predicted value prob['trig.x'] = np.array([2.1, 3.2, 4.3]) prob.run_model() assert_near_equal( prob['trig.y'], np.column_stack( (.5 * np.sin(prob['trig.x']), .5 * np.cos(prob['trig.x']))), 1e-4)
def test_array_inputs(self): mm = om.MetaModelUnStructuredComp() mm.add_input('x', np.zeros((2, 2))) mm.add_output('y1', 0.) mm.add_output('y2', 0.) mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() mm.options['train:x'] = [[[1.0, 1.0], [1.0, 1.0]], [[2.0, 1.0], [1.0, 1.0]], [[1.0, 2.0], [1.0, 1.0]], [[1.0, 1.0], [2.0, 1.0]], [[1.0, 1.0], [1.0, 2.0]]] mm.options['train:y1'] = [3.0, 2.0, 1.0, 6.0, -2.0] mm.options['train:y2'] = [1.0, 4.0, 7.0, -3.0, 3.0] prob['mm.x'] = [[1.0, 2.0], [1.0, 1.0]] prob.run_model() assert_rel_error(self, prob['mm.y1'], 1.0, .00001) assert_rel_error(self, prob['mm.y2'], 7.0, .00001)
def test_vectorized_kriging(self): # Test for coverage (handling the rmse) size = 3 # create a vectorized MetaModelUnStructuredComp for sine trig = om.MetaModelUnStructuredComp( vec_size=size, default_surrogate=om.KrigingSurrogate(eval_rmse=True)) trig.add_input('x', np.zeros(size)) trig.add_output('y', np.zeros(size)) # add it to a Problem prob = om.Problem() prob.model.add_subsystem('trig', trig) prob.setup() # provide training data trig.options['train:x'] = np.linspace(0, 10, 20) trig.options['train:y'] = .5 * np.sin(trig.options['train:x']) # train the surrogate and check predicted value prob['trig.x'] = np.array([2.1, 3.2, 4.3]) prob.run_model() assert_near_equal(prob['trig.y'], np.array(.5 * np.sin(prob['trig.x'])), 1e-4) self.assertEqual(len(prob.model.trig._metadata('y')['rmse']), 3)
def test_kriging_options_eval_rmse(self): prob = om.Problem() sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 2.1) sin_mm.add_output('f_x', 0., surrogate=om.KrigingSurrogate(eval_rmse=True)) prob.model.add_subsystem('sin_mm', sin_mm) prob.setup(check=True) # train the surrogate and check predicted value sin_mm.options['train_x'] = np.linspace(0, 10, 20) sin_mm.options['train_f_x'] = .5 * np.sin(sin_mm.options['train_x']) prob.set_val('sin_mm.x', 2.1) prob.run_model() print("mean") assert_near_equal(prob.get_val('sin_mm.f_x'), .5 * np.sin(prob.get_val('sin_mm.x')), 1e-4) print("std") assert_near_equal(sin_mm._metadata('f_x')['rmse'][0, 0], 0.0, 1e-4)
def test_unequal_training_outputs(self): mm = om.MetaModelUnStructuredComp() mm.add_input('x', 0.) mm.add_input('y', 0.) mm.add_output('f', 0.) mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() mm.options['train:x'] = [1.0, 1.0, 1.0, 1.0] mm.options['train:y'] = [1.0, 2.0, 3.0, 4.0] mm.options['train:f'] = [1.0, 1.0] prob['mm.x'] = 1.0 prob['mm.y'] = 1.0 with self.assertRaises(RuntimeError) as cm: prob.run_model() expected = ( "MetaModelUnStructuredComp (mm): Each variable must have the same number" " of training points. Expected 4 but found" " 2 points for 'f'.") self.assertEqual(str(cm.exception), expected)
def test_sin_metamodel_rmse(self): # create MetaModelUnStructuredComp with Kriging, using the rmse option sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 0.) sin_mm.add_output('f_x', 0.) sin_mm.options['default_surrogate'] = om.KrigingSurrogate( eval_rmse=True) # add it to a Problem prob = om.Problem() prob.model.add_subsystem('sin_mm', sin_mm) prob.setup() # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 10, 20) sin_mm.options['train:f_x'] = np.sin(sin_mm.options['train:x']) prob['sin_mm.x'] = 2.1 prob.run_model() assert_near_equal(prob['sin_mm.f_x'], np.sin(2.1), 1e-4) # mean self.assertTrue( self, sin_mm._metadata('f_x')['rmse'] < 1e-5) # std deviation
def test_2darray_outputs(self): mm = om.MetaModelUnStructuredComp() mm.add_input('x', np.zeros((2, 2))) mm.add_output('y', np.zeros((2, 2))) mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() mm.options['train:x'] = [[[1.0, 1.0], [1.0, 1.0]], [[2.0, 1.0], [1.0, 1.0]], [[1.0, 2.0], [1.0, 1.0]], [[1.0, 1.0], [2.0, 1.0]], [[1.0, 1.0], [1.0, 2.0]]] mm.options['train:y'] = [[[3.0, 1.0], [3.0, 1.0]], [[2.0, 4.0], [2.0, 4.0]], [[1.0, 7.0], [1.0, 7.0]], [[6.0, -3.0], [6.0, -3.0]], [[-2.0, 3.0], [-2.0, 3.0]]] prob['mm.x'] = [[1.0, 2.0], [1.0, 1.0]] prob.run_model() assert_near_equal(prob['mm.y'], np.array([[1.0, 7.0], [1.0, 7.0]]), .00001)
def test_surrogate_message_format(self): prob = om.Problem() prob.model.add_subsystem('p', om.IndepVarComp('x', 2.1)) sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 0.) sin_mm.add_output('f_x', 0., surrogate=om.KrigingSurrogate()) prob.model.add_subsystem('sin_mm', sin_mm) prob.model.connect('p.x', 'sin_mm.x') prob.setup(check=True) # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 10, 1) sin_mm.options['train:f_x'] = .5 * np.sin(sin_mm.options['train:x']) prob['sin_mm.x'] = 2.1 with self.assertRaises(ValueError) as cm: prob.run_model() self.assertEqual( str(cm.exception), 'sin_mm: KrigingSurrogate requires at least' ' 2 training points.')
def test_kriging_options_eval_rmse(self): import numpy as np import openmdao.api as om prob = om.Problem() prob.model.add_subsystem('p', om.IndepVarComp('x', 2.1)) sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 0.) sin_mm.add_output('f_x', 0., surrogate=om.KrigingSurrogate(eval_rmse=True)) prob.model.add_subsystem('sin_mm', sin_mm) prob.model.connect('p.x', 'sin_mm.x') prob.setup(check=True) # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 10, 20) sin_mm.options['train:f_x'] = .5 * np.sin(sin_mm.options['train:x']) prob['sin_mm.x'] = 2.1 prob.run_model() print("mean") assert_near_equal(prob['sin_mm.f_x'], .5 * np.sin(prob['sin_mm.x']), 1e-4) print("std") assert_near_equal(sin_mm._metadata('f_x')['rmse'][0, 0], 0.0, 1e-4)
def test_vectorized(self): size = 3 # create a vectorized MetaModelUnStructuredComp for sine trig = om.MetaModelUnStructuredComp( vec_size=size, default_surrogate=om.KrigingSurrogate()) trig.add_input('x', np.zeros(size)) trig.add_output('y', np.zeros(size)) # add it to a Problem prob = om.Problem() prob.model.add_subsystem('trig', trig) prob.setup() # provide training data trig.options['train_x'] = np.linspace(0, 10, 20) trig.options['train_y'] = .5 * np.sin(trig.options['train_x']) # train the surrogate and check predicted value prob['trig.x'] = np.array([2.1, 3.2, 4.3]) prob.run_model() assert_near_equal(prob['trig.y'], np.array(.5 * np.sin(prob['trig.x'])), 1e-4) data = prob.check_partials(out_stream=None) assert_check_partials(data, atol=1e-6, rtol=1e-6)
def test_kriging(self): import numpy as np import openmdao.api as om prob = om.Problem() prob.model.add_subsystem('p', om.IndepVarComp('x', 2.1)) sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 0.) sin_mm.add_output('f_x', 0., surrogate=om.KrigingSurrogate()) prob.model.add_subsystem('sin_mm', sin_mm) prob.model.connect('p.x', 'sin_mm.x') prob.setup(check=True) # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 10, 20) sin_mm.options['train:f_x'] = .5 * np.sin(sin_mm.options['train:x']) prob['sin_mm.x'] = 2.1 prob.run_model() assert_rel_error(self, prob['sin_mm.f_x'], .5 * np.sin(prob['sin_mm.x']), 1e-4)
def test_two_vector_inputs(self): mm = om.MetaModelUnStructuredComp() mm.add_input('x1', np.zeros(4)) mm.add_input('x2', np.zeros(4)) mm.add_output('y1', 0.) mm.add_output('y2', 0.) mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() mm.options['train_x1'] = [[1.0, 1.0, 1.0, 1.0], [2.0, 1.0, 1.0, 1.0], [1.0, 2.0, 1.0, 1.0], [1.0, 1.0, 2.0, 1.0], [1.0, 1.0, 1.0, 2.0]] mm.options['train_x2'] = [[1.0, 1.0, 1.0, 1.0], [2.0, 1.0, 1.0, 1.0], [1.0, 2.0, 1.0, 1.0], [1.0, 1.0, 2.0, 1.0], [1.0, 1.0, 1.0, 2.0]] mm.options['train_y1'] = [3.0, 2.0, 1.0, 6.0, -2.0] mm.options['train_y2'] = [1.0, 4.0, 7.0, -3.0, 3.0] prob['mm.x1'] = [1.0, 2.0, 1.0, 1.0] prob['mm.x2'] = [1.0, 2.0, 1.0, 1.0] prob.run_model() assert_near_equal(prob['mm.y1'], 1.0, .00001) assert_near_equal(prob['mm.y2'], 7.0, .00001)
def test_metamodel_feature2d(self): # similar to previous example, but output is 2d import numpy as np import openmdao.api as om # create a MetaModelUnStructuredComp that predicts sine and cosine as an array trig = om.MetaModelUnStructuredComp( default_surrogate=om.KrigingSurrogate()) trig.add_input('x', 0) trig.add_output('y', np.zeros(2)) # add it to a Problem prob = om.Problem() prob.model.add_subsystem('trig', trig) prob.setup() # provide training data trig.options['train:x'] = np.linspace(0, 10, 20) trig.options['train:y'] = np.column_stack( (.5 * np.sin(trig.options['train:x']), .5 * np.cos(trig.options['train:x']))) # train the surrogate and check predicted value prob['trig.x'] = 2.1 prob.run_model() assert_near_equal( prob['trig.y'], np.append(.5 * np.sin(prob['trig.x']), .5 * np.cos(prob['trig.x'])), 1e-4)
def test_kriging(self): import numpy as np import openmdao.api as om prob = om.Problem() sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 2.1) sin_mm.add_output('f_x', 0., surrogate=om.KrigingSurrogate()) prob.model.add_subsystem('sin_mm', sin_mm) prob.setup(check=True) # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 10, 20) sin_mm.options['train:f_x'] = .5 * np.sin(sin_mm.options['train:x']) prob.set_val('sin_mm.x', 2.1) prob.run_model() assert_near_equal(prob.get_val('sin_mm.f_x'), .5 * np.sin(prob.get_val('sin_mm.x')), 1e-4)
def test_vectorized(self): size = 3 # create a vectorized MetaModelUnStructuredComp for sine trig = om.MetaModelUnStructuredComp( vec_size=size, default_surrogate=om.KrigingSurrogate()) trig.add_input('x', np.zeros(size)) trig.add_output('y', np.zeros(size)) # add it to a Problem prob = om.Problem() prob.model.add_subsystem('trig', trig) prob.setup() # provide training data trig.options['train:x'] = np.linspace(0, 10, 20) trig.options['train:y'] = .5 * np.sin(trig.options['train:x']) # train the surrogate and check predicted value prob['trig.x'] = np.array([2.1, 3.2, 4.3]) prob.run_model() assert_near_equal(prob['trig.y'], np.array(.5 * np.sin(prob['trig.x'])), 1e-4) data = prob.check_partials(out_stream=None) abs_errors = data['trig'][('y', 'x')]['abs error'] self.assertTrue(len(abs_errors) > 0) for match in abs_errors: abs_error = float(match) self.assertTrue(abs_error < 1.e-6)
def setup(self): self.add_input('x', 0., training_data=np.linspace(0,10,20)) self.add_output('sin_x', 0., surrogate=om.KrigingSurrogate(), training_data=.5*np.sin(np.linspace(0,10,20))) self.declare_partials(of='sin_x', wrt='x', method='fd')
def test_derivatives_vectorized_multiD(self): vec_size = 5 mm = om.MetaModelUnStructuredComp(vec_size=vec_size) mm.add_input('x', np.zeros((vec_size, 2, 3))) mm.add_input('xx', np.zeros((vec_size, 1))) mm.add_output('y', np.zeros((vec_size, 4, 2))) mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() mm.options['train_x'] = [[[1.0, 2.0, 1.0], [1.0, 2.0, 1.0]], [[2.0, 1.0, 1.0], [1.0, 1.0, 1.0]], [[1.0, 1.0, 2.0], [1.0, 2.0, 1.0]], [[1.0, 1.0, 1.0], [2.0, 1.0, 1.0]], [[1.0, 2.0, 1.0], [1.0, 2.0, 2.0]]] mm.options['train_xx'] = [1.0, 2.0, 1.0, 1.0, 2.0] mm.options['train_y'] = [[[30.0, 10.0], [30.0, 25.0], [50.0, 10.7], [15.0, 25.7]], [[20.0, 40.0], [20.0, 40.0], [80.0, 30.3], [12.0, 20.7]], [[10.0, 70.0], [10.0, 70.0], [20.0, 10.9], [13.0, 15.7]], [[60.0, -30.0], [60.0, -30.0], [50.0, 50.5], [14.0, 10.7]], [[-20.0, 30.0], [-20.0, 30.0], [20.2, 10.0], [15.0, 60.7]]] prob['mm.x'] = [[[1.3, 1.3, 1.3], [1.5, 1.5, 1.5]], [[1.4, 1.4, 1.4], [1.5, 1.5, 1.5]], [[1.5, 1.5, 1.5], [1.5, 1.5, 1.5]], [[1.5, 1.5, 1.5], [1.4, 1.4, 1.4]], [[1.5, 1.5, 1.5], [1.3, 1.3, 1.3]]] prob['mm.xx'] = [[1.4], [1.5], [1.6], [1.5], [1.4]] prob.run_model() data = prob.check_partials(out_stream=None) assert_check_partials(data, atol=1e-5, rtol=1e-5) # Complex step prob.setup(force_alloc_complex=True) prob.model.mm.set_check_partial_options(wrt='*', method='cs') data = prob.check_partials(out_stream=None) assert_check_partials(data, atol=1e-11, rtol=1e-11)
def test_sin_metamodel(self): # create a MetaModelUnStructuredComp for sine and add it to a om.Problem sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 0.) sin_mm.add_output('f_x', 0.) prob = om.Problem() prob.model.add_subsystem('sin_mm', sin_mm) # check that missing surrogate is detected in check_config testlogger = TestLogger() prob.setup(check=True, logger=testlogger) # Conclude setup but don't run model. prob.final_setup() msg = ("No default surrogate model is defined and the " "following outputs do not have a surrogate model:\n" "['f_x']\n" "Either specify a default_surrogate, or specify a " "surrogate model for all outputs.") self.assertEqual(len(testlogger.get('error')), 1) self.assertTrue(msg in testlogger.get('error')[0]) # check that output with no specified surrogate gets the default sin_mm.options['default_surrogate'] = om.KrigingSurrogate() prob.setup() surrogate = sin_mm._metadata('f_x').get('surrogate') self.assertTrue(isinstance(surrogate, om.KrigingSurrogate), 'sin_mm.f_x should get the default surrogate') # check error message when no training data is provided with self.assertRaises(RuntimeError) as cm: prob.run_model() msg = ( "MetaModelUnStructuredComp (sin_mm): The following training data sets must be " "provided as options: ['train:x', 'train:f_x']") self.assertEqual(str(cm.exception), msg) # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 10, 20) sin_mm.options['train:f_x'] = .5 * np.sin(sin_mm.options['train:x']) prob['sin_mm.x'] = 2.1 prob.run_model() assert_near_equal(prob['sin_mm.f_x'], .5 * np.sin(prob['sin_mm.x']), 1e-4)
def test_derivatives(self): mm = om.MetaModelUnStructuredComp() mm.add_input('x', 0.) mm.add_output('f', 0.) mm.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('p', om.IndepVarComp('x', 0.), promotes_outputs=['x']) prob.model.add_subsystem('mm', mm, promotes_inputs=['x']) prob.setup() mm.options['train:x'] = [0., .25, .5, .75, 1.] mm.options['train:f'] = [1., .75, .5, .25, 0.] prob['x'] = 0.125 prob.run_model() data = prob.check_partials(out_stream=None) Jf = data['mm'][('f', 'x')]['J_fwd'] Jr = data['mm'][('f', 'x')]['J_rev'] assert_rel_error(self, Jf[0][0], -1., 1.e-3) assert_rel_error(self, Jr[0][0], -1., 1.e-3) abs_errors = data['mm'][('f', 'x')]['abs error'] self.assertTrue(len(abs_errors) > 0) for match in abs_errors: abs_error = float(match) self.assertTrue(abs_error < 1.e-6) # Complex step prob.setup(force_alloc_complex=True) prob.model.mm.set_check_partial_options(wrt='*', method='cs') data = prob.check_partials(out_stream=None) abs_errors = data['mm'][('f', 'x')]['abs error'] self.assertTrue(len(abs_errors) > 0) for match in abs_errors: abs_error = float(match) self.assertTrue(abs_error < 1.e-6)
def test_sin_metamodel_preset_data(self): # preset training data x = np.linspace(0, 10, 200) f_x = .5 * np.sin(x) # create a MetaModelUnStructuredComp for Sin and add it to a Problem sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 0., training_data=x) sin_mm.add_output('f_x', 0., training_data=f_x) prob = om.Problem() prob.model.add_subsystem('sin_mm', sin_mm) # check that missing surrogate is detected in check_setup testlogger = TestLogger() prob.setup(check=True, logger=testlogger) # Conclude setup but don't run model. prob.final_setup() msg = ("No default surrogate model is defined and the " "following outputs do not have a surrogate model:\n" "['f_x']\n" "Either specify a default_surrogate, or specify a " "surrogate model for all outputs.") self.assertEqual(len(testlogger.get('error')), 1) self.assertTrue(msg in testlogger.get('error')[0]) # check that output with no specified surrogate gets the default sin_mm.options['default_surrogate'] = om.KrigingSurrogate() prob.setup() surrogate = sin_mm._metadata('f_x').get('surrogate') self.assertTrue(isinstance(surrogate, om.KrigingSurrogate), 'sin_mm.f_x should get the default surrogate') prob['sin_mm.x'] = 2.22 prob.run_model() assert_near_equal(prob['sin_mm.f_x'], .5 * np.sin(prob['sin_mm.x']), 1e-4)
def CFM56(num_nodes=1, plot=False): """ Returns OpenMDAO component for engine deck to model CFM56 turbofan. Inputs ------ throttle: float Engine throttle. Controls power and fuel flow. Produces 100% of rated power at throttle = 1. Should be in range 0 to 1 or slightly above 1. (vector, dimensionless) fltcond|h: float Altitude (vector, dimensionless) fltcond|M: float Mach number (vector, dimensionless) Outputs ------- thrust : float Thrust developed by the engine (vector, lbf) fuel_flow : float Fuel flow consumed (vector, lbm/s) T4 : float Turbine inlet temperature (vector, Rankine) Options ------- num_nodes : int Number of analysis points to run (sets vec length; default 1) """ file_root = openconcept.__path__[0] + r'/components/empirical_data/cfm56/' thrustdata = np.load(file_root + 'cfm56thrust.npy') fuelburndata = np.load(file_root + 'cfm56wf.npy') t4data = np.load(file_root + r'cfm56t4.npy') krigedata = [] for ialt, altitude in enumerate( np.array([35, 30, 25, 20, 15, 10, 5, 0]) * 1000.): for jmach, mach in enumerate( np.array([8, 7, 6, 5, 4, 3, 2, 1, 0.]) * 0.1): for kthrot, throttle in enumerate( np.array([10, 9, 8, 7, 6, 5, 4, 3, 2]) * 0.1): thrustijk = thrustdata[ialt, jmach, kthrot] if thrustijk > 0.0: if not (mach > 0.5 and altitude == 0.0): krigedata.append( np.array([ throttle, altitude, mach, thrustijk.copy(), fuelburndata[ialt, jmach, kthrot].copy(), t4data[ialt, jmach, kthrot].copy() ])) a = np.array(krigedata) comp = om.MetaModelUnStructuredComp(vec_size=num_nodes) comp.add_input('throttle', np.ones((num_nodes, )) * 1., training_data=a[:, 0], units=None) comp.add_input('fltcond|h', np.ones((num_nodes, )) * 0., training_data=a[:, 1], units='ft') comp.add_input('fltcond|M', np.ones((num_nodes, )) * 0.3, training_data=a[:, 2], units=None) comp.add_output('thrust', np.ones((num_nodes, )) * 10000., training_data=a[:, 3], units='lbf', surrogate=om.KrigingSurrogate(training_cache=file_root + 'cfm56thrust_trained.zip')) comp.add_output('fuel_flow', np.ones((num_nodes, )) * 3.0, training_data=a[:, 4], units='lbm/s', surrogate=om.KrigingSurrogate(training_cache=file_root + 'cfm56fuelburn_trained.zip')) comp.add_output('T4', np.ones((num_nodes, )) * 3000., training_data=a[:, 5], units='degR', surrogate=om.KrigingSurrogate(training_cache=file_root + 'cfm56T4_trained.zip')) comp.options['default_surrogate'] = om.KrigingSurrogate( lapack_driver='gesvd') if plot: import matplotlib.pyplot as plt prob = om.Problem() prob.model.add_subsystem('comp', comp) prob.setup() machs = np.linspace(0.0, 0.8, 25) alts = np.linspace(0.0, 35000., 25) machs, alts = np.meshgrid(machs, alts) pred = np.zeros((25, 25, 3)) for i in range(25): for j in range(25): prob['comp.throttle'] = 1.0 prob['comp.fltcond|h'] = alts[i, j] prob['comp.fltcond|M'] = machs[i, j] prob.run_model() pred[i, j, 0] = prob['comp.thrust'][0].copy() pred[i, j, 1] = prob['comp.fuel_flow'][0].copy() plt.figure() plt.xlabel('Mach') plt.ylabel('Altitude') plt.title('SFC (lb / hr lb) OM') # plt.contourf(machs, alts, pred[:,:,0]) plt.contourf(machs, alts, (pred[:, :, 1] / pred[:, :, 0]) * 60 * 60) plt.colorbar() plt.figure() plt.xlabel('Mach') plt.ylabel('Altitude') plt.title('Thrust (lb)') # plt.contourf(machs, alts, pred[:,:,0]) plt.contourf(machs, alts, pred[:, :, 1], levels=20) plt.colorbar() plt.figure() plt.xlabel('Mach') plt.ylabel('Altitude') plt.title('Fuel Flow (lb)') # plt.contourf(machs, alts, pred[:,:,0]) plt.contourf(machs, alts, pred[:, :, 0], levels=20) plt.colorbar() plt.show() return comp
prob1.run_driver() prob1.cleanup() cr = om.CaseReader("cases.sql") cases = cr.list_cases('driver') values = [] for case in cases: outputs = cr.get_case(case).outputs values.append((outputs['RadLen'], outputs['T_max'])) print("\n".join(["RadLen: %5.2f, T_max: %6.2f" % xf for xf in values])) metamod = om.MetaModelUnStructuredComp() metamod.add_input('x', 0.) metamod.add_output('y', 0., surrogate=om.KrigingSurrogate()) # train the surrogate values = np.array(values) metamod.options['train:x'] = values[:, 0] metamod.options['train:y'] = values[:, 1] # create and connect inputs prob2 = om.Problem() model = prob2.model indeps = model.add_subsystem('indeps', IndepVarComp()) indeps.add_output('RadLen', 0.4) indeps.add_output('width', 0.2) model.add_subsystem('obj', ExecComp('A = length * width')) model.add_subsystem('mm', metamod) model.connect('indeps.RadLen', ['mm.x', 'obj.length'])
#Python script for optimization of MAT remote unit thermal model @cold analysis case using surrogate model import os, time from openmdao.api import Problem, Group, IndepVarComp, ExternalCode, ScipyOptimizeDriver, SimpleGADriver, ExecComp, ExplicitComponent import numpy as np import openmdao.api as om train = np.loadtxt('./TrainingData/RUc_TrainingData[ese]_n=300.csv', delimiter=',') # train the surrogate ru_mm = om.MetaModelUnStructuredComp(default_surrogate=om.KrigingSurrogate()) ru_mm.add_input('eps', training_data=train[:, 0]) ru_mm.add_input('length', training_data=train[:, 1]) ru_mm.add_input('eff', training_data=train[:, 2]) ru_mm.add_input('P_ht', training_data=train[:, 3]) ru_mm.add_input('r_bat', training_data=train[:, 4]) ru_mm.add_input('R_m', training_data=train[:, 5]) ru_mm.add_input('R_p', training_data=train[:, 6]) ru_mm.add_input('R_s', training_data=train[:, 7]) ru_mm.add_output('tBat', training_data=train[:, 8]) prob = Problem() model = prob.model # create and connect inputs and outputs indeps = model.add_subsystem('indeps', IndepVarComp(), promotes=['*']) indeps.add_output('eps', val=0.02) indeps.add_output('length', val=0.2) indeps.add_output('eff', val=0.25) indeps.add_output('P_ht', val=0.2)
def create_model(name): # Setup training domain l = 1 nb_sp = 25 d1 = np.linspace(-l, l, nb_sp) d2 = d1 X, Y = np.meshgrid(d1, d2) Z = function(X, Y) # Setup prediction domain a = np.linspace(-l, l, 100) pd1 = a * np.sin(a**2) pd2 = a * np.cos(a**2) po = [] err = [] # Computing the surface coord = [] res = [] for i in d1: for j in d2: res.append(function(i, j)) coord.append([i, j]) # Create the training dataset xi = np.array(coord) yi = np.transpose(np.atleast_2d(res)) # Create and train the model if name == 'Kg': k = om.KrigingSurrogate() elif name == 'RS': k = om.ResponseSurface() print('train start') k.train(xi, yi) print('train stop') # Make a prediction for i in range(0, len(a)): pres = k.predict(np.array([pd1[i], pd2[i]])) if name == 'Kg': po.append(pres[-1][-1]) err.append(po[-1] - function(pd1[i], pd2[i])) elif name == 'RS': po.append(pres[-1]) err.append(po[-1] - function(pd1[i], pd2[i])) rms = np.sqrt(np.mean(np.array(err)**2)) print('Root mean-square error {} : {}'.format(name, rms)) # Plot the training set plt.figure() ax = plt.axes(projection='3d') # ax.plot_surface(X, Y, Z) ax.plot_wireframe(X, Y, Z) #Plot the predicted set ax.scatter(pd1, pd2, po, color='red') ax.plot(pd1, pd2, err, color='gray') ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z') # plt.show() return rms
import numpy as np from math import pi import openmdao.api as om # Model interp = om.MetaModelUnStructuredComp() # Training Data x_train1 = np.random.uniform(0, pi, 100) x_train2 = np.random.uniform(0, pi, 100) x_train3 = np.random.uniform(0, pi, 100) y = np.sin(x_train1 * x_train2 * x_train3) # Inputs interp.add_input('input_1', 0., training_data=x_train1) interp.add_input('input_2', 0., training_data=x_train2) interp.add_input('input_3', 0., training_data=x_train3) # Outputs interp.add_output('output_1', 0., training_data=y) # Surrogate Model interp.options['default_surrogate'] = om.KrigingSurrogate() prob = om.Problem() prob.model.add_subsystem('interp', interp) prob.setup() prob.final_setup()