def __init__(self): super(ConvergeDivergeGroups, self).__init__() self.add_subsystem('iv', IndepVarComp('x', 2.0)) g1 = self.add_subsystem('g1', ParallelGroup()) g1.add_subsystem('c1', ExecComp(['y1 = 2.0*x1**2', 'y2 = 3.0*x1'])) g2 = g1.add_subsystem('g2', ParallelGroup()) g2.add_subsystem('c2', ExecComp('y1 = 0.5*x1')) g2.add_subsystem('c3', ExecComp('y1 = 3.5*x1')) g1.add_subsystem( 'c4', ExecComp(['y1 = x1 + 2.0*x2', 'y2 = 3.0*x1 - 5.0*x2'])) g3 = self.add_subsystem('g3', ParallelGroup()) g3.add_subsystem('c5', ExecComp('y1 = 0.8*x1')) g3.add_subsystem('c6', ExecComp('y1 = 0.5*x1')) self.add_subsystem('c7', ExecComp('y1 = x1 + 3.0*x2')) # make connections self.connect('iv.x', 'g1.c1.x1') g1.connect('c1.y1', 'g2.c2.x1') g1.connect('c1.y2', 'g2.c3.x1') self.connect('g1.g2.c2.y1', 'g1.c4.x1') self.connect('g1.g2.c3.y1', 'g1.c4.x2') self.connect('g1.c4.y1', 'g3.c5.x1') self.connect('g1.c4.y2', 'g3.c6.x1') self.connect('g3.c5.y1', 'c7.x1') self.connect('g3.c6.y1', 'c7.x2')
def __init__(self): super(Diamond, self).__init__() self.add_subsystem('iv', IndepVarComp('x', 2.0)) self.add_subsystem('c1', ExecComp([ 'y1 = 2.0*x1**2', 'y2 = 3.0*x1' ])) sub = self.add_subsystem('sub', ParallelGroup()) sub.add_subsystem('c2', ExecComp('y1 = 0.5*x1')) sub.add_subsystem('c3', ExecComp('y1 = 3.5*x1')) self.add_subsystem('c4', ExecComp([ 'y1 = x1 + 2.0*x2', 'y2 = 3.0*x1 - 5.0*x2' ])) # make connections self.connect('iv.x', 'c1.x1') self.connect('c1.y1', 'sub.c2.x1') self.connect('c1.y2', 'sub.c3.x1') self.connect('sub.c2.y1', 'c4.x1') self.connect('sub.c3.y1', 'c4.x2')
def test_parallel_diamond(self): size = 3 prob = Problem(Group(), impl=impl) root = prob.root root.add('P1', ParamComp('x', np.ones(size, float) * 1.1)) G1 = root.add('G1', ParallelGroup()) G1.add('C1', ABCDArrayComp(size)) G1.add('C2', ABCDArrayComp(size)) root.add('C3', ABCDArrayComp(size)) root.connect('P1.x', 'G1.C1.a') root.connect('P1.x', 'G1.C2.b') root.connect('G1.C1.c', 'C3.a') root.connect('G1.C2.d', 'C3.b') prob.setup(check=False) prob.run() if not MPI or self.comm.rank == 0: assert_rel_error(self, prob.root.G1.C1.unknowns['c'], np.ones(size) * 2.1, 1.e-10) assert_rel_error(self, prob.root.G1.C1.unknowns['d'], np.ones(size) * .1, 1.e-10) assert_rel_error(self, prob.root.C3.params['a'], np.ones(size) * 2.1, 1.e-10) assert_rel_error(self, prob.root.C3.params['b'], np.ones(size) * -.1, 1.e-10) if not MPI or self.comm.rank == 1: assert_rel_error(self, prob.root.G1.C2.unknowns['c'], np.ones(size) * 2.1, 1.e-10) assert_rel_error(self, prob.root.G1.C2.unknowns['d'], np.ones(size) * -.1, 1.e-10)
def test_driver_records_metadata(self): size = 3 prob = Problem(Group(), impl=impl) G1 = prob.root.add('G1', ParallelGroup()) G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0)) G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0)) prob.root.add('C1', ABCDArrayComp(size)) prob.root.connect('G1.P1.x', 'C1.a') prob.root.connect('G1.P2.x', 'C1.b') prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = True prob.setup(check=False) prob.cleanup() expected = ( list(prob.root.params.iteritems()), list(prob.root.unknowns.iteritems()), list(prob.root.resids.iteritems()), ) self.assertMetadataRecorded(expected)
def test_indices(self): asize = 3 prob = Problem(root=Group(), impl=impl) root = prob.root root.ln_solver = LinearGaussSeidel() root.ln_solver.options['mode'] = 'rev' p = root.add('p', ParamComp('x', np.arange(asize, dtype=float) + 1.0)) G1 = root.add('G1', ParallelGroup()) G1.ln_solver = LinearGaussSeidel() G1.ln_solver.options['mode'] = 'rev' c2 = G1.add( 'c2', ExecComp4Test('y = x * 2.0', x=np.zeros(asize), y=np.zeros(asize))) c3 = G1.add( 'c3', ExecComp4Test('y = numpy.ones(3).T*x.dot(numpy.arange(3.,6.))', x=np.zeros(asize), y=np.zeros(asize))) c4 = root.add( 'c4', ExecComp4Test('y = x * 4.0', x=np.zeros(asize), y=np.zeros(asize))) c5 = root.add( 'c5', ExecComp4Test('y = x * 5.0', x=np.zeros(asize), y=np.zeros(asize))) prob.driver.add_param('p.x', indices=[1, 2]) prob.driver.add_constraint('c4.y', indices=[1]) prob.driver.add_constraint('c5.y', indices=[2]) prob.driver.parallel_derivs(['c4.y', 'c5.y']) root.connect('p.x', 'G1.c2.x') root.connect('p.x', 'G1.c3.x') root.connect('G1.c2.y', 'c4.x') root.connect('G1.c3.y', 'c5.x') prob.setup(check=False) prob.run() J = prob.calc_gradient(['p.x'], ['c4.y', 'c5.y'], mode='fwd', return_format='dict') assert_rel_error(self, J['c5.y']['p.x'][0], np.array([20., 25.]), 1e-6) assert_rel_error(self, J['c4.y']['p.x'][0], np.array([8., 0.]), 1e-6) J = prob.calc_gradient(['p.x'], ['c4.y', 'c5.y'], mode='rev', return_format='dict') assert_rel_error(self, J['c5.y']['p.x'][0], np.array([20., 25.]), 1e-6) assert_rel_error(self, J['c4.y']['p.x'][0], np.array([8., 0.]), 1e-6)
def test_basic(self): size = 3 prob = Problem(Group(), impl=impl) G1 = prob.root.add('G1', ParallelGroup()) G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0)) G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0)) prob.root.add('C1', ABCDArrayComp(size)) prob.root.connect('G1.P1.x', 'C1.a') prob.root.connect('G1.P2.x', 'C1.b') prob.driver.add_recorder(self.recorder) self.recorder.options['record_params'] = True self.recorder.options['record_resids'] = True prob.setup(check=False) t0, t1 = run(prob) prob.cleanup() coordinate = ['Driver', (1, )] expected_params = [ ("C1.a", [1.0, 1.0, 1.0]), ("C1.b", [2.0, 2.0, 2.0]), ] expected_unknowns = [ ("G1.P1.x", np.array([1.0, 1.0, 1.0])), ("G1.P2.x", np.array([2.0, 2.0, 2.0])), ("C1.c", np.array([3.0, 3.0, 3.0])), ("C1.d", np.array([-1.0, -1.0, -1.0])), ("C1.out_string", "_C1"), ("C1.out_list", [1.5]), ] expected_resids = [ ("G1.P1.x", np.array([0.0, 0.0, 0.0])), ("G1.P2.x", np.array([0.0, 0.0, 0.0])), ("C1.c", np.array([0.0, 0.0, 0.0])), ("C1.d", np.array([0.0, 0.0, 0.0])), ("C1.out_string", ""), ("C1.out_list", []), ] self.assertIterationDataRecorded( ((coordinate, (t0, t1), expected_params, expected_unknowns, expected_resids), ), self.eps, prob.root)
def __init__(self): super(FanInGrouped, self).__init__() self.add('p1', ParamComp('x1', 1.0)) self.add('p2', ParamComp('x2', 1.0)) sub = self.add('sub', ParallelGroup()) sub.add('comp1', ExecComp(['y=-2.0*x'])) sub.add('comp2', ExecComp(['y=5.0*x'])) self.add('comp3', ExecComp(['y=3.0*x1+7.0*x2'])) self.connect("sub.comp1.y", "comp3.x1") self.connect("sub.comp2.y", "comp3.x2") self.connect("p1.x1", "sub.comp1.x") self.connect("p2.x2", "sub.comp2.x")
def __init__(self): super(ConvergeDivergePar, self).__init__() self.add('p', IndepVarComp('x', 2.0)) self.add('comp1', Comp1()) par1 = self.add('par1', ParallelGroup()) par1.add('comp2', Comp2()) par1.add('comp3', Comp3()) self.add('comp4', Comp4()) par2 = self.add('par2', ParallelGroup()) par2.add('comp5', Comp5()) par2.add('comp6', Comp6()) self.add('comp7', Comp7()) self.connect("p.x", "comp1.x1") self.connect('comp1.y1', 'par1.comp2.x1') self.connect('comp1.y2', 'par1.comp3.x1') self.connect('par1.comp2.y1', 'comp4.x1') self.connect('par1.comp3.y1', 'comp4.x2') self.connect('comp4.y1', 'par2.comp5.x1') self.connect('comp4.y2', 'par2.comp6.x1') self.connect('par2.comp5.y1', 'comp7.x1') self.connect('par2.comp6.y1', 'comp7.x2')
def __init__(self): super(SingleDiamondPar, self).__init__() self.add('p', IndepVarComp('x', 2.0)) self.add('comp1', Comp1()) sub = self.add('sub', ParallelGroup()) sub.add('comp2', Comp2()) sub.add('comp3', Comp3()) self.add('comp4', Comp4()) self.connect("p.x", "comp1.x1") self.connect('comp1.y1', 'sub.comp2.x1') self.connect('comp1.y2', 'sub.comp3.x1') self.connect('sub.comp2.y1', 'comp4.x1') self.connect('sub.comp3.y1', 'comp4.x2')
def __init__(self): super(FanInGrouped2, self).__init__() p1 = self.add_subsystem('p1', IndepVarComp('x', 1.0)) p2 = self.add_subsystem('p2', IndepVarComp('x', 1.0)) self.sub = self.add_subsystem('sub', ParallelGroup()) self.sub.add_subsystem('c1', ExecComp(['y=-2.0*x'])) self.sub.add_subsystem('c2', ExecComp(['y=5.0*x'])) self.add_subsystem('c3', ExecComp(['y=3.0*x1+7.0*x2'])) self.connect("sub.c1.y", "c3.x1") self.connect("sub.c2.y", "c3.x2") self.connect("p1.x", "sub.c1.x") self.connect("p2.x", "sub.c2.x")
def __init__(self): super(FanOutGrouped, self).__init__() self.add('p', ParamComp('x', 1.0)) self.add('comp1', ExecComp(['y=3.0*x'])) sub = self.add('sub', ParallelGroup()) sub.add('comp2', ExecComp(['y=-2.0*x'])) sub.add('comp3', ExecComp(['y=5.0*x'])) self.add('c2', ExecComp(['y=x'])) self.add('c3', ExecComp(['y=x'])) self.connect('sub.comp2.y', 'c2.x') self.connect('sub.comp3.y', 'c3.x') self.connect("comp1.y", "sub.comp2.x") self.connect("comp1.y", "sub.comp3.x") self.connect("p.x", "comp1.x")
def setup(self): sub = self.add_subsystem('sub', ParallelGroup()) sub1 = sub.add_subsystem('sub1', Group()) sub2 = sub.add_subsystem('sub2', Group()) sub1.add_subsystem('p1', IndepVarComp('x', 3.0)) sub2.add_subsystem('p2', IndepVarComp('x', 5.0)) sub1.add_subsystem('c1', ExecComp(['y = 2.0*x'])) sub2.add_subsystem('c2', ExecComp(['y = 4.0*x'])) sub1.connect('p1.x', 'c1.x') sub2.connect('p2.x', 'c2.x') self.add_subsystem('sum', ExecComp(['y = z1 + z2'])) self.connect('sub.sub1.c1.y', 'sum.z1') self.connect('sub.sub2.c2.y', 'sum.z2') self.sub.sub1.add_design_var('p1.x') self.sub.sub2.add_design_var('p2.x') self.add_objective('sum.y')
def __init__(self): super(FanInGrouped, self).__init__() iv = self.add_subsystem('iv', IndepVarComp()) iv.add_output('x1', 1.0) iv.add_output('x2', 1.0) iv.add_output('x3', 1.0) self.sub = self.add_subsystem('sub', ParallelGroup()) self.sub.add_subsystem('c1', ExecComp(['y=-2.0*x'])) self.sub.add_subsystem('c2', ExecComp(['y=5.0*x'])) self.add_subsystem('c3', ExecComp(['y=3.0*x1+7.0*x2'])) self.connect("sub.c1.y", "c3.x1") self.connect("sub.c2.y", "c3.x2") self.connect("iv.x1", "sub.c1.x") self.connect("iv.x2", "sub.c2.x")
def __init__(self): super(FanOutGroupedVarSets, self).__init__() self.add_subsystem('iv', IndepVarComp('x', 1.0)) self.add_subsystem('c1', ExecComp('y=3.0*x', x={'var_set': 2})) self.sub = self.add_subsystem('sub', ParallelGroup()) self.sub.add_subsystem('c2', ExecComp('y=-2.0*x', x={'var_set': 2})) self.sub.add_subsystem('c3', ExecComp('y=5.0*x', x={'var_set': 3})) self.add_subsystem('c2', ExecComp('y=x', x={'var_set': 2})) self.add_subsystem('c3', ExecComp('y=x', x={'var_set': 3})) self.connect('iv.x', 'c1.x') self.connect('c1.y', 'sub.c2.x') self.connect('c1.y', 'sub.c3.x') self.connect('sub.c2.y', 'c2.x') self.connect('sub.c3.y', 'c3.x')
def test_driver_doesnt_records_metadata(self): size = 3 prob = Problem(Group(), impl=impl) G1 = prob.root.add('G1', ParallelGroup()) G1.add('P1', IndepVarComp('x', np.ones(size, float) * 1.0)) G1.add('P2', IndepVarComp('x', np.ones(size, float) * 2.0)) prob.root.add('C1', ABCDArrayComp(size)) prob.root.connect('G1.P1.x', 'C1.a') prob.root.connect('G1.P2.x', 'C1.b') prob.driver.add_recorder(self.recorder) self.recorder.options['record_metadata'] = False prob.setup(check=False) prob.cleanup() self.assertMetadataRecorded(None)
def test_parallel_fan_in(self): size = 3 prob = Problem(Group(), impl=impl) G1 = prob.root.add('G1', ParallelGroup()) G1.add('P1', ParamComp('x', np.ones(size, float) * 1.0)) G1.add('P2', ParamComp('x', np.ones(size, float) * 2.0)) prob.root.add('C1', ABCDArrayComp(size)) prob.root.connect('G1.P1.x', 'C1.a') prob.root.connect('G1.P2.x', 'C1.b') prob.setup(check=False) prob.run() if not MPI or self.comm.rank == 0: self.assertTrue( all(prob.root.C1.params['a'] == np.ones(size, float) * 1.0)) self.assertTrue( all(prob.root.C1.params['b'] == np.ones(size, float) * 2.0)) self.assertTrue(all(prob['C1.c'] == np.ones(size, float) * 3.0)) self.assertTrue(all(prob['C1.d'] == np.ones(size, float) * -1.0))
cname = "C%d" % (num_comps - 1) self.add_objective("%s.o0" % cname) self.add_constraint("%s.o1" % cname, lower=0.0) p = Problem() g = p.model if 'gmres' in sys.argv: from openmdao.solvers.linear.scipy_iter_solver import ScipyKrylov g.linear_solver = ScipyKrylov() g.add_subsystem("P", IndepVarComp('x', numpy.ones(vec_size))) g.add_design_var("P.x") par = g.add_subsystem("par", ParallelGroup()) for pt in range(pts): ptname = "G%d" % pt ptg = par.add_subsystem(ptname, SubGroup()) #create_dyncomps(ptg, num_comps, 2, 2, 2, #var_factory=lambda: numpy.zeros(vec_size)) g.connect("P.x", "par.%s.C0.i0" % ptname) #cname = ptname + '.' + "C%d"%(num_comps-1) #g.add_objective("par.%s.o0" % cname) #g.add_constraint("par.%s.o1" % cname, lower=0.0) p.setup() p.final_setup() p.run_model() #
def test_distributed_list_vars(self): from openmdao.utils.general_utils import set_pyoptsparse_opt # check that pyoptsparse is installed. if it is, try to use SLSQP. OPT, OPTIMIZER = set_pyoptsparse_opt('SLSQP') if OPTIMIZER: from openmdao.drivers.pyoptsparse_driver import pyOptSparseDriver else: raise unittest.SkipTest("pyOptSparseDriver is required.") from openmdao.core.parallel_group import ParallelGroup from openmdao.components.exec_comp import ExecComp class Mygroup(Group): def setup(self): self.add_subsystem('indep_var_comp', IndepVarComp('x'), promotes=['*']) self.add_subsystem('Cy', ExecComp('y=2*x'), promotes=['*']) self.add_subsystem('Cc', ExecComp('c=x+2'), promotes=['*']) self.add_design_var('x') self.add_constraint('c', lower=-3.) prob = Problem() prob.model.add_subsystem('par', ParallelGroup()) prob.model.par.add_subsystem('G1', Mygroup()) prob.model.par.add_subsystem('G2', Mygroup()) prob.model.add_subsystem('Obj', ExecComp('obj=y1+y2')) prob.model.connect('par.G1.y', 'Obj.y1') prob.model.connect('par.G2.y', 'Obj.y2') prob.model.add_objective('Obj.obj') prob.driver = pyOptSparseDriver() prob.driver.options['optimizer'] = 'SLSQP' prob.setup() prob.run_driver() prob.cleanup() stream = cStringIO() inputs = sorted(prob.model.list_inputs(values=True, print_arrays=True, out_stream=stream)) self.assertEqual(inputs[0][0], 'Obj.y1') self.assertEqual(inputs[1][0], 'Obj.y2') if prob.comm.rank: # Only rank 0 prints self.assertEqual(inputs[2][0], 'par.G2.Cc.x') self.assertEqual(inputs[3][0], 'par.G2.Cy.x') else: self.assertEqual(inputs[2][0], 'par.G1.Cc.x') self.assertEqual(inputs[3][0], 'par.G1.Cy.x') self.assertTrue('value' in inputs[0][1]) self.assertEqual(4, len(inputs)) text = stream.getvalue() if prob.comm.rank: # Only rank 0 prints self.assertEqual(len(text), 0) else: self.assertEqual(1, text.count("6 Input(s) in 'model'"), 1) self.assertEqual(1, text.count('value')) self.assertEqual(1, text.count(' par')) self.assertEqual(1, text.count(' G1')) self.assertEqual(1, text.count(' G2')) self.assertEqual(2, text.count(' Cy')) self.assertEqual(2, text.count(' Cc')) self.assertEqual(4, text.count(' x')) self.assertEqual(1, text.count(' Obj')) self.assertEqual(1, text.count(' y1')) self.assertEqual(1, text.count(' y2')) stream = cStringIO() outputs = sorted(prob.model.list_outputs(values=True, units=True, shape=True, bounds=True, residuals=True, scaling=True, hierarchical=True, print_arrays=True, out_stream=stream)) self.assertEqual(outputs[0][0], 'Obj.obj') if prob.comm.rank: # outputs only return what is on their proc self.assertEqual(outputs[1][0], 'par.G2.Cc.c') self.assertEqual(outputs[2][0], 'par.G2.Cy.y') self.assertEqual(outputs[3][0], 'par.G2.indep_var_comp.x') else: self.assertEqual(outputs[1][0], 'par.G1.Cc.c') self.assertEqual(outputs[2][0], 'par.G1.Cy.y') self.assertEqual(outputs[3][0], 'par.G1.indep_var_comp.x') self.assertEqual(4, len(outputs)) self.assertTrue('value' in outputs[0][1]) self.assertTrue('units' in outputs[0][1]) text = stream.getvalue() if prob.comm.rank: # Only rank 0 prints self.assertEqual(len(text), 0) else: self.assertEqual(1, text.count("7 Explicit Output(s) in 'model'")) self.assertEqual(1, text.count('value')) self.assertEqual(1, text.count('units')) self.assertEqual(1, text.count(' par')) self.assertEqual(1, text.count(' G1')) self.assertEqual(1, text.count(' G2')) self.assertEqual(2, text.count(' Cy')) self.assertEqual(2, text.count(' Cc')) self.assertEqual(2, text.count(' indep_var_comp')) self.assertEqual(2, text.count(' x')) self.assertEqual(2, text.count(' y')) self.assertEqual(2, text.count(' c')) self.assertEqual(1, text.count(' Obj')) self.assertEqual(1, text.count(' obj'))
else: from openmdao.core.basic_impl import BasicImpl impl = BasicImpl g = Group() p = Problem(impl=impl, root=g) if 'gmres' in sys.argv: from openmdao.solvers.scipy_gmres import ScipyGMRES p.root.ln_solver = ScipyGMRES() g.add("P", IndepVarComp('x', numpy.ones(vec_size))) p.driver.add_desvar("P.x") par = g.add("par", ParallelGroup()) for pt in range(pts): ptname = "G%d" % pt ptg = par.add(ptname, Group()) create_dyncomps(ptg, num_comps, 2, 2, 2, var_factory=lambda: numpy.zeros(vec_size)) g.connect("P.x", "par.%s.C0.p0" % ptname) cname = ptname + '.' + "C%d" % (num_comps - 1) p.driver.add_objective("par.%s.o0" % cname) p.driver.add_constraint("par.%s.o1" % cname, lower=0.0)
def __init__(self, n=1500, m=300, npts=6): super(CADRE_MDP_Group, self).__init__() # Raw data to load fpath = os.path.dirname(os.path.realpath(__file__)) fpath = os.path.join(fpath, 'data') solar_raw1 = np.genfromtxt(fpath + '/Solar/Area10.txt') solar_raw2 = np.loadtxt(fpath + '/Solar/Area_all.txt') comm_rawGdata = np.genfromtxt(fpath + '/Comm/Gain.txt') comm_raw = (10**(comm_rawGdata / 10.0)).reshape((361, 361), order='F') power_raw = np.genfromtxt(fpath + '/Power/curve.dat') # Load launch data launch_data = np.loadtxt(fpath + '/Launch/launch1.dat') # orbit position and velocity data for each design point r_e2b_I0s = launch_data[1::2, 1:] # number of days since launch for each design point LDs = launch_data[1::2, 0] - 2451545 # Create ParmComps for broadcast parameters. self.add('bp1', IndepVarComp('cellInstd', np.ones((7, 12)))) self.add('bp2', IndepVarComp('finAngle', np.pi / 4.0)) self.add('bp3', IndepVarComp('antAngle', 0.0)) # CADRE instances go into a Parallel Group para = self.add('parallel', ParallelGroup(), promotes=['*']) # build design points names = ['pt%s' % i for i in range(npts)] for i, name in enumerate(names): # Some initial values inits = {} inits['LD'] = float(LDs[i]) inits['r_e2b_I0'] = r_e2b_I0s[i] comp = para.add( name, CADRE(n, m, solar_raw1, solar_raw2, comm_raw, power_raw, initial_params=inits)) # Hook up broadcast params self.connect('bp1.cellInstd', "%s.cellInstd" % name) self.connect('bp2.finAngle', "%s.finAngle" % name) self.connect('bp3.antAngle', "%s.antAngle" % name) self.add('%s_con5' % name, ExecComp("val = SOCi - SOCf")) self.connect("%s.SOC" % name, '%s_con5.SOCi' % name, src_indices=[0]) self.connect("%s.SOC" % name, '%s_con5.SOCf' % name, src_indices=[n - 1]) obj = ''.join([" - %s_DataTot" % name for name in names]) self.add('obj', ExecComp('val=' + obj)) for name in names: self.connect("%s.Data" % name, "obj.%s_DataTot" % name, src_indices=[n - 1]) # Set our groups to auto self.ln_solver.options['mode'] = 'auto' para.ln_solver.options['mode'] = 'auto'