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'