def __init__(self):
super(SellarDerivativesGrouped, self).__init__()
self.add('px', IndepVarComp('x', 1.0), promotes=['*'])
self.add('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['*'])
mda = self.add('mda', Group(), promotes=['*'])
mda.ln_solver = ScipyGMRES()
mda.add('d1', SellarDis1withDerivatives(), promotes=['*'])
mda.add('d2', SellarDis2withDerivatives(), promotes=['*'])
self.add('obj_cmp',
ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]),
x=0.0,
y1=0.0,
y2=0.0),
promotes=['*'])
self.add('con_cmp1', ExecComp('con1 = 3.16 - y1'), promotes=['*'])
self.add('con_cmp2', ExecComp('con2 = y2 - 24.0'), promotes=['*'])
mda.nl_solver = NLGaussSeidel()
mda.d1.fd_options['force_fd'] = True
mda.d2.fd_options['force_fd'] = True
self.ln_solver = ScipyGMRES()
def __init__(self):
super(SellarStateConnection, self).__init__()
self.add('px', IndepVarComp('x', 1.0), promotes=['*'])
self.add('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['*'])
sub = self.add('sub', Group(), promotes=['*'])
sub.ln_solver = ScipyGMRES()
subgrp = sub.add('state_eq_group', Group(), promotes=['*'])
subgrp.ln_solver = ScipyGMRES()
subgrp.add('state_eq', StateConnection())
sub.add('d1', SellarDis1withDerivatives(), promotes=['x', 'z', 'y1'])
sub.add('d2', SellarDis2withDerivatives(), promotes=['z', 'y1'])
self.connect('state_eq.y2_command', 'd1.y2')
self.connect('d2.y2', 'state_eq.y2_actual')
self.add('obj_cmp', ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]), x=0.0, y1=0.0, y2=0.0),
promotes=['x', 'z', 'y1', 'obj'])
self.connect('d2.y2', 'obj_cmp.y2')
self.add('con_cmp1', ExecComp('con1 = 3.16 - y1'), promotes=['con1', 'y1'])
self.add('con_cmp2', ExecComp('con2 = y2 - 24.0'), promotes=['con2'])
self.connect('d2.y2', 'con_cmp2.y2')
self.nl_solver = Newton()
def __init__(self):
super(SellarDerivatives, self).__init__()
self.add('px', IndepVarComp('x', 1.0), promotes=['x'])
self.add('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z'])
self.add('d1',
SellarDis1withDerivatives(),
promotes=['x', 'z', 'y1', 'y2'])
self.add('d2', SellarDis2withDerivatives(), promotes=['z', 'y1', 'y2'])
self.add('obj_cmp',
ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]),
x=0.0),
promotes=['obj', 'x', 'z', 'y1', 'y2'])
self.add('con_cmp1',
ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
self.add('con_cmp2',
ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
self.nl_solver = NLGaussSeidel()
self.ln_solver = ScipyGMRES()
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 __init__(self):
super(SellarNoDerivatives, self).__init__()
self.add('px', IndepVarComp('x', 1.0), promotes=['x'])
self.add('pz', IndepVarComp('z', np.array([5.0, 2.0])), promotes=['z'])
cycle = self.add('cycle', Group(), promotes=['x', 'z', 'y1', 'y2'])
cycle.ln_solver = ScipyGMRES()
cycle.add('d1', SellarDis1(), promotes=['x', 'z', 'y1', 'y2'])
cycle.add('d2', SellarDis2(), promotes=['z', 'y1', 'y2'])
self.add('obj_cmp',
ExecComp('obj = x**2 + z[1] + y1 + exp(-y2)',
z=np.array([0.0, 0.0]),
x=0.0),
promotes=['x', 'z', 'y1', 'y2', 'obj'])
self.add('con_cmp1',
ExecComp('con1 = 3.16 - y1'),
promotes=['con1', 'y1'])
self.add('con_cmp2',
ExecComp('con2 = y2 - 24.0'),
promotes=['con2', 'y2'])
self.nl_solver = NLGaussSeidel()
self.cycle.d1.deriv_options['type'] = 'fd'
self.cycle.d2.deriv_options['type'] = 'fd'
def test_unknown_vec(self):
top = Problem()
top.root = Group()
top.root.add('comp', ArrayComp2D(), promotes=['x', 'y'])
top.root.add('p1',
IndepVarComp('x', np.array([[1.0, 2.0], [3.0, 4.0]])),
promotes=['x'])
top.root.add('comp2', SimpleComp())
top.root.add('p2', IndepVarComp('x', 3.0))
top.root.connect('p2.x', 'comp2.x')
top.setup(check=False)
top.run()
unknowns = ComplexStepSrcVecWrapper(top.root.comp.unknowns)
# Unknowns are always complex
y = unknowns['y']
self.assertTrue(y.dtype == np.complex)
self.assertEquals(y[0, 1], 46.0 + 0j)
# Set an unknown
unknowns['y'][0, 1] = 13.0 + 17.0j
self.assertEquals(unknowns['y'][0, 1], 13.0 + 17.0j)
# Extract flat var
cval = unknowns.flat('y')
self.assertEquals(cval[1], 13.0 + 17.0j)
self.assertEquals(cval.shape[0], 4)
unknowns = ComplexStepSrcVecWrapper(top.root.comp2.unknowns)
# Unknowns are always complex
y = unknowns['y']
self.assertTrue(y.dtype == np.complex)
self.assertEquals(y, 6.0 + 0j)
# Set an unknown
unknowns['y'] = 13.0 + 17.0j
self.assertEquals(unknowns['y'], 13.0 + 17.0j)
# Extract flat var
cval = unknowns.flat('y')
self.assertEquals(cval, 13.0 + 17.0j)
self.assertEquals(cval.shape[0], 1)
# Make sure all other functions work for coverage
self.assertEquals(len(unknowns), 1)
self.assertTrue('y' in unknowns)
plist = [z for z in unknowns]
self.assertEquals(plist, ['y'])
self.assertEquals(unknowns.keys(), top.root.comp2.unknowns.keys())
self.assertEquals(unknowns.metadata('y'),
top.root.comp2.unknowns.metadata('y'))
plist1 = [z for z in unknowns.iterkeys()]
plist2 = [z for z in top.root.comp2.unknowns.iterkeys()]
def __init__(self):
super(FanIn, self).__init__()
self.add('p1', IndepVarComp('x1', 1.0))
self.add('p2', IndepVarComp('x2', 1.0))
self.add('comp1', ExecComp(['y=-2.0*x']))
self.add('comp2', ExecComp(['y=5.0*x']))
self.add('comp3', ExecComp(['y=3.0*x1+7.0*x2']))
self.connect("comp1.y", "comp3.x1")
self.connect("comp2.y", "comp3.x2")
self.connect("p1.x1", "comp1.x")
self.connect("p2.x2", "comp2.x")
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(ConvergeDivergeGroups, self).__init__()
self.add('p', IndepVarComp('x', 2.0))
sub1 = self.add('sub1', Group())
sub1.add('comp1', Comp1())
sub2 = sub1.add('sub2', Group())
sub2.add('comp2', Comp2())
sub2.add('comp3', Comp3())
sub1.add('comp4', Comp4())
sub3 = self.add('sub3', Group())
sub3.add('comp5', Comp5())
sub3.add('comp6', Comp6())
self.add('comp7', Comp7())
self.connect("p.x", "sub1.comp1.x1")
self.connect('sub1.comp1.y1', 'sub1.sub2.comp2.x1')
self.connect('sub1.comp1.y2', 'sub1.sub2.comp3.x1')
self.connect('sub1.sub2.comp2.y1', 'sub1.comp4.x1')
self.connect('sub1.sub2.comp3.y1', 'sub1.comp4.x2')
self.connect('sub1.comp4.y1', 'sub3.comp5.x1')
self.connect('sub1.comp4.y2', 'sub3.comp6.x1')
self.connect('sub3.comp5.y1', 'comp7.x1')
self.connect('sub3.comp6.y1', 'comp7.x2')
def __init__(self):
super(FanInGrouped, self).__init__()
self.add('p1', IndepVarComp('x1', 1.0))
self.add('p2', IndepVarComp('x2', 1.0))
self.add('p3', IndepVarComp('x3', 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 test_simple_float(self):
prob = Problem()
prob.root = root = Group()
root.add('x_param', IndepVarComp('x', 17.0), promotes=['x'])
root.add('y_param', IndepVarComp('y', 19.0), promotes=['y'])
root.add('mycomp', Paraboloid(), promotes=['x', 'y', 'f_xy'])
# This will give poor FD, but good CS
root.mycomp.fd_options['step_size'] = 1.0e1
root.mycomp.fd_options['force_fd'] = True
root.mycomp.fd_options['form'] = 'complex_step'
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['f_xy'], mode='fwd', return_format='dict')
assert_rel_error(self, J['f_xy']['x'][0][0], 47.0, 1e-6)
def __init__(self):
super(FanOut, self).__init__()
self.add('p', IndepVarComp('x', 1.0))
self.add('comp1', ExecComp(['y=3.0*x']))
self.add('comp2', ExecComp(['y=-2.0*x']))
self.add('comp3', ExecComp(['y=5.0*x']))
self.connect("comp1.y", "comp2.x")
self.connect("comp1.y", "comp3.x")
self.connect("p.x", "comp1.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 __init__(self):
super(SingleDiamond, self).__init__()
self.add('p', IndepVarComp('x', 2.0))
self.add('comp1', Comp1())
self.add('comp2', Comp2())
self.add('comp3', Comp3())
self.add('comp4', Comp4())
self.connect("p.x", "comp1.x1")
self.connect('comp1.y1', 'comp2.x1')
self.connect('comp1.y2', 'comp3.x1')
self.connect('comp2.y1', 'comp4.x1')
self.connect('comp3.y1', 'comp4.x2')
def __init__(self):
super(ExampleByObjGroup, self).__init__()
self.G2 = self.add('G2', Group())
self.C1 = self.G2.add('C1', IndepVarComp('x', 'foo'))
self.G1 = self.G2.add('G1', Group())
self.C2 = self.G1.add('C2', SimplePassByObjComp())
self.G3 = self.add('G3', Group())
self.C3 = self.G3.add('C3', SimplePassByObjComp())
self.C4 = self.G3.add('C4', SimplePassByObjComp())
self.G2.connect('C1.x', 'G1.C2.x')
self.connect('G2.G1.C2.y', 'G3.C3.x')
self.G3.connect('C3.y', 'C4.x')
def __init__(self):
super(ExampleGroup, self).__init__()
self.G2 = self.add('G2', Group())
self.C1 = self.G2.add('C1', IndepVarComp('x', 5.))
self.G1 = self.G2.add('G1', Group())
self.C2 = self.G1.add('C2', ExecComp('y=x*2.0', x=3., y=5.5))
self.G3 = self.add('G3', Group())
self.C3 = self.G3.add('C3', ExecComp('y=x*2.0', x=3., y=5.5))
self.C4 = self.G3.add('C4', ExecComp('y=x*2.0', x=3., y=5.5))
self.G2.connect('C1.x', 'G1.C2.x')
self.connect('G2.G1.C2.y', 'G3.C3.x')
self.G3.connect('C3.y', 'C4.x')
def __init__(self):
super(FanOutGrouped, self).__init__()
self.add('p', IndepVarComp('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):
self.prob = Problem()
self.prob.root = Group()
self.prob.root.add('tt',TubeTemp())
params = (
('P', 0.304434211, {'units':'psi'}),
('T', 1710., {'units':'degR'})
)
self.prob.root.add('des_vars', IndepVarComp(params), promotes=['*'])
self.prob.root.connect('P', 'tt.nozzle_air.P')
self.prob.root.connect('T', 'tt.nozzle_air.T')
self.prob.root.connect('P', 'tt.bearing_air.P')
self.prob.root.connect('T', 'tt.bearing_air.T')
self.prob.setup(check=True)
def __init__(self):
super(TubeLimitFlow, self).__init__()
self.add('Mach_param', IndepVarComp('Mach', 1.0), promotes=['Mach'])
#self.add('Mach_con', ConstraintComp('Mach > 0.0'))
self.add('tube_struct', TubeStructural())
self.add('inlet', InletGeom())
self.add('AR_comp',
AreaRatio(),
promotes=['Mach_bypass', 'bypass_area'])
self.add('tube_thermo', TubeThermo())
self.add('tube_total', SetTotal(init_reacts=AIR_MIX, mode='T'))
self.add('tube_static', SetStaticMN(init_reacts=AIR_MIX))
self.add('bypass_total', SetTotal(init_reacts=AIR_MIX, mode='T'))
self.add('bypass_static', SetStaticMN(init_reacts=AIR_MIX))
self.add('tube_aero',
TubeAero(),
promotes=['tube_area', 'W_tube', 'W_kant', 'W_excess'])
self.connect('Mach', 'AR_comp.Mach')
#self.connect('Mach', 'Mach_con.Mach')
self.connect('tube_struct.tube_r', 'AR_comp.tube_r')
self.connect('inlet.area_out', 'AR_comp.inlet_area')
self.connect('Mach', 'tube_thermo.Mach')
self.connect('tube_thermo.Pt', 'tube_total.P')
self.connect('tube_thermo.Tt', 'tube_total.T')
self.connect('tube_thermo.Pt', 'bypass_total.P')
self.connect('tube_thermo.Tt', 'bypass_total.T')
self.connect('tube_total.S', 'tube_static.S')
self.connect('tube_total.h', 'tube_static.ht')
self.connect('tube_total.P', 'tube_static.Pt')
self.connect('tube_total.gamma', 'tube_static.gamt')
self.connect('bypass_total.S', 'bypass_static.S')
self.connect('bypass_total.h', 'bypass_static.ht')
self.connect('bypass_total.P', 'bypass_static.Pt')
self.connect('bypass_total.gamma', 'bypass_static.gamt')
self.connect('Mach', 'tube_static.MN_target')
self.connect('Mach_bypass', 'bypass_static.MN_target')
self.connect('tube_static.V', 'tube_aero.velocity_tube')
self.connect('bypass_static.V', 'tube_aero.velocity_bypass')
self.connect('tube_total.rho', 'tube_aero.rho_tube')
self.connect('bypass_total.rho', 'tube_aero.rho_bypass')
self.connect('bypass_area', 'tube_aero.bypass_area')
self.connect('tube_struct.tube_r', 'tube_aero.tube_r')
def __init__(self):
super(FanOutAllGrouped, self).__init__()
self.add('p', IndepVarComp('x', 1.0))
sub1 = self.add('sub1', Group())
sub1.add('comp1', ExecComp(['y=3.0*x']))
sub2 = self.add('sub2', Group())
sub2.add('comp2', ExecComp(['y=-2.0*x']))
sub3 = self.add('sub3', Group())
sub3.add('comp3', ExecComp(['y=5.0*x']))
self.add('c2', ExecComp(['y=x']))
self.add('c3', ExecComp(['y=x']))
self.connect('sub2.comp2.y', 'c2.x')
self.connect('sub3.comp3.y', 'c3.x')
self.connect("sub1.comp1.y", "sub2.comp2.x")
self.connect("sub1.comp1.y", "sub3.comp3.x")
self.connect("p.x", "sub1.comp1.x")
def setup(self, compname, inputs, state0):
self.model.root.add('comp',
eval('%s(NTIME)' % compname),
promotes=['*'])
for item in inputs + state0:
pshape = self.model.root.comp._params_dict[item]['shape']
self.model.root.add('p_%s' % item,
IndepVarComp(item, np.zeros((pshape))),
promotes=['*'])
self.model.setup(check=False)
for item in inputs + state0:
val = self.model['%s' % item]
if hasattr(val, 'shape'):
shape1 = val.shape
self.model['%s' % item] = np.random.random(shape1)
else:
self.model['%s' % item] = np.random.random()
def test_array2D(self):
prob = Problem()
prob.root = root = Group()
root.add('x_param', IndepVarComp('x', np.ones((2, 2))), promotes=['*'])
root.add('mycomp', ArrayComp2D(), promotes=['x', 'y'])
root.mycomp.deriv_options['step_size'] = 1.0e-1
root.mycomp.deriv_options['type'] = 'cs'
prob.setup(check=False)
prob.run()
J = prob.calc_gradient(['x'], ['y'], mode='fwd', return_format='dict')
Jbase = prob.root.mycomp._jacobian_cache
diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x'])
assert_rel_error(self, diff, 0.0, 1e-8)
J = prob.calc_gradient(['x'], ['y'], mode='rev', return_format='dict')
diff = np.linalg.norm(J['y']['x'] - Jbase['y', 'x'])
assert_rel_error(self, diff, 0.0, 1e-8)
def __init__(self):
super(ConvergeDiverge, self).__init__()
self.add('p', IndepVarComp('x', 2.0))
self.add('comp1', Comp1())
self.add('comp2', Comp2())
self.add('comp3', Comp3())
self.add('comp4', Comp4())
self.add('comp5', Comp5())
self.add('comp6', Comp6())
self.add('comp7', Comp7())
self.connect("p.x", "comp1.x1")
self.connect('comp1.y1', 'comp2.x1')
self.connect('comp1.y2', 'comp3.x1')
self.connect('comp2.y1', 'comp4.x1')
self.connect('comp3.y1', 'comp4.x2')
self.connect('comp4.y1', 'comp5.x1')
self.connect('comp4.y2', 'comp6.x1')
self.connect('comp5.y1', 'comp7.x1')
self.connect('comp6.y1', 'comp7.x2')
def test_OMModelWrapper(self):
logging.debug('')
logging.debug('test_OMModelWrapper')
this_dir_path = os.path.realpath(os.path.dirname(__file__))
addl_lib_path = os.path.join(this_dir_path, 'VehicleDesign.mo')
problem = Problem()
root = problem.root = Group()
test_model = OMModelWrapper('SimAcceleration', addl_lib_path)
root.add('simacceleration', test_model)
root.add('simtime', IndepVarComp('duration', val='15.0'))
root.connect('simtime.duration', 'simacceleration.stopTime')
dump_filename = 'dump.log'
# Delete old dumpfile
try:
os.remove(dump_filename)
except OSError:
pass
recorder = DumpRecorder(dump_filename)
recorder.options['record_params'] = True
recorder.options['record_metadata'] = True
recorder.options['record_resids'] = True
problem.driver.add_recorder(recorder)
problem.setup()
problem.run()
problem.driver.recorders[0].close()
self.assertTrue(os.path.exists(dump_filename))
with open(dump_filename) as dumpf:
dump = dumpf.readlines()
self.assertTrue(' simtime.duration: 15.0\n' in dump)
self.assertTrue(
' simacceleration.accel_time: [ 0. 0. 0. ..., 15. 15. 15.]\n'
in dump)
def test_unit_convert(self):
prob = Problem()
prob.root = Group()
prob.root.add('src', SrcComp())
prob.root.add('tgtF', TgtCompF())
prob.root.add('tgtC', TgtCompC())
prob.root.add('tgtK', TgtCompK())
prob.root.add('px1', IndepVarComp('x1', 100.0), promotes=['x1'])
prob.root.connect('x1', 'src.x1')
prob.root.connect('src.x2', 'tgtF.x2')
prob.root.connect('src.x2', 'tgtC.x2')
prob.root.connect('src.x2', 'tgtK.x2')
prob.setup(check=False)
prob.run()
p1 = ComplexStepTgtVecWrapper(prob.root.tgtF.params)
p2 = ComplexStepTgtVecWrapper(prob.root.tgtC.params)
p3 = ComplexStepTgtVecWrapper(prob.root.tgtK.params)
assert_rel_error(self, p1['x2'], 212.0, 1.0e-6)
assert_rel_error(self, p2['x2'], 100.0, 1.0e-6)
assert_rel_error(self, p3['x2'], 373.15, 1.0e-6)
from openmdao.components.indep_var_comp import IndepVarComp
if __name__ == "__main__":
# -------------------------
# --- Default Test Case ---
# -------------------------
p1 = Problem()
p1.root = Group()
#p1.root.add("freestream",Freestream())
p1.root.add("fs", FlowStart())
params = (
('P', 0.5, {
"units": "psi"
}),
('T', 291.0, {
"units": "K"
}),
('MN', 0.8),
)
p1.root.add('des_vars', IndepVarComp(params))
p1.root.connect('des_vars.P', 'fs.P')
#p1.root.connect('des_vars.MN', 'fs.MN')
p1.root.connect('des_vars.T', 'fs.T')
p1.setup(check=False)
p1.run()
p1.root.list_connections()
print("total P: ", p1["fs.Fl_O:tot:P"])
print("static P: ", p1["fs.Fl_O:stat:P"])
def __init__(self,
n,
m,
solar_raw1=None,
solar_raw2=None,
comm_raw=None,
power_raw=None,
initial_params=None):
super(CADRE, self).__init__()
self.ln_solver.options['mode'] = 'auto'
# Analysis parameters
self.n = n
self.m = m
h = 43200.0 / (self.n - 1)
# User-defined initial parameters
if initial_params is None:
initial_params = {}
if 't1' not in initial_params:
initial_params['t1'] = 0.0
if 't2' not in initial_params:
initial_params['t2'] = 43200.0
if 't' not in initial_params:
initial_params['t'] = np.array(range(0, n)) * h
if 'CP_Isetpt' not in initial_params:
initial_params['CP_Isetpt'] = 0.2 * np.ones((12, self.m))
if 'CP_gamma' not in initial_params:
initial_params['CP_gamma'] = np.pi / 4 * np.ones((self.m, ))
if 'CP_P_comm' not in initial_params:
initial_params['CP_P_comm'] = 0.1 * np.ones((self.m, ))
if 'iSOC' not in initial_params:
initial_params['iSOC'] = np.array([0.5])
# Fixed Station Parameters for the CADRE problem.
# McMurdo station: -77.85, 166.666667
# Ann Arbor: 42.2708, -83.7264
if 'LD' not in initial_params:
initial_params['LD'] = 5000.0
if 'lat' not in initial_params:
initial_params['lat'] = 42.2708
if 'lon' not in initial_params:
initial_params['lon'] = -83.7264
if 'alt' not in initial_params:
initial_params['alt'] = 0.256
# Initial Orbital Elements
if 'r_e2b_I0' not in initial_params:
initial_params['r_e2b_I0'] = np.zeros((6, ))
# Some initial setup.
self.add('p_t1',
IndepVarComp('t1', initial_params['t1']),
promotes=['*'])
self.add('p_t2',
IndepVarComp('t2', initial_params['t2']),
promotes=['*'])
self.add('p_t', IndepVarComp('t', initial_params['t']), promotes=['*'])
# Design parameters
self.add('p_CP_Isetpt',
IndepVarComp('CP_Isetpt', initial_params['CP_Isetpt']),
promotes=['*'])
self.add('p_CP_gamma',
IndepVarComp('CP_gamma', initial_params['CP_gamma']),
promotes=['*'])
self.add('p_CP_P_comm',
IndepVarComp('CP_P_comm', initial_params['CP_P_comm']),
promotes=['*'])
self.add('p_iSOC',
IndepVarComp('iSOC', initial_params['iSOC']),
promotes=['*'])
# These are broadcast params in the MDP.
#self.add('p_cellInstd', IndepVarComp('cellInstd', np.ones((7, 12))),
# promotes=['*'])
#self.add('p_finAngle', IndepVarComp('finAngle', np.pi / 4.), promotes=['*'])
#self.add('p_antAngle', IndepVarComp('antAngle', 0.0), promotes=['*'])
self.add('param_LD',
IndepVarComp('LD', initial_params['LD']),
promotes=['*'])
self.add('param_lat',
IndepVarComp('lat', initial_params['lat']),
promotes=['*'])
self.add('param_lon',
IndepVarComp('lon', initial_params['lon']),
promotes=['*'])
self.add('param_alt',
IndepVarComp('alt', initial_params['alt']),
promotes=['*'])
self.add('param_r_e2b_I0',
IndepVarComp('r_e2b_I0', initial_params['r_e2b_I0']),
promotes=['*'])
# Add Component Models
self.add("BsplineParameters", BsplineParameters(n, m), promotes=['*'])
self.add("Attitude_Angular", Attitude_Angular(n), promotes=['*'])
self.add("Attitude_AngularRates",
Attitude_AngularRates(n, h),
promotes=['*'])
self.add("Attitude_Attitude", Attitude_Attitude(n), promotes=['*'])
self.add("Attitude_Roll", Attitude_Roll(n), promotes=['*'])
self.add("Attitude_RotationMtx",
Attitude_RotationMtx(n),
promotes=['*'])
self.add("Attitude_RotationMtxRates",
Attitude_RotationMtxRates(n, h),
promotes=['*'])
# Not needed?
#self.add("Attitude_Sideslip", Attitude_Sideslip(n))
self.add("Attitude_Torque", Attitude_Torque(n), promotes=['*'])
self.add("BatteryConstraints", BatteryConstraints(n), promotes=['*'])
self.add("BatteryPower", BatteryPower(n), promotes=['*'])
self.add("BatterySOC", BatterySOC(n, h), promotes=['*'])
self.add("Comm_AntRotation", Comm_AntRotation(n), promotes=['*'])
self.add("Comm_AntRotationMtx", Comm_AntRotationMtx(n), promotes=['*'])
self.add("Comm_BitRate", Comm_BitRate(n), promotes=['*'])
self.add("Comm_DataDownloaded",
Comm_DataDownloaded(n, h),
promotes=['*'])
self.add("Comm_Distance", Comm_Distance(n), promotes=['*'])
self.add("Comm_EarthsSpin", Comm_EarthsSpin(n), promotes=['*'])
self.add("Comm_EarthsSpinMtx", Comm_EarthsSpinMtx(n), promotes=['*'])
self.add("Comm_GainPattern",
Comm_GainPattern(n, comm_raw),
promotes=['*'])
self.add("Comm_GSposEarth", Comm_GSposEarth(n), promotes=['*'])
self.add("Comm_GSposECI", Comm_GSposECI(n), promotes=['*'])
self.add("Comm_LOS", Comm_LOS(n), promotes=['*'])
self.add("Comm_VectorAnt", Comm_VectorAnt(n), promotes=['*'])
self.add("Comm_VectorBody", Comm_VectorBody(n), promotes=['*'])
self.add("Comm_VectorECI", Comm_VectorECI(n), promotes=['*'])
self.add("Comm_VectorSpherical",
Comm_VectorSpherical(n),
promotes=['*'])
# Not needed?
#self.add("Orbit_Initial", Orbit_Initial())
self.add("Orbit_Dynamics", Orbit_Dynamics(n, h), promotes=['*'])
self.add("Power_CellVoltage",
Power_CellVoltage(n, power_raw),
promotes=['*'])
self.add("Power_SolarPower", Power_SolarPower(n), promotes=['*'])
self.add("Power_Total", Power_Total(n), promotes=['*'])
# Not needed?
#self.add("ReactionWheel_Motor", ReactionWheel_Motor(n))
self.add("ReactionWheel_Power", ReactionWheel_Power(n), promotes=['*'])
self.add("ReactionWheel_Torque",
ReactionWheel_Torque(n),
promotes=['*'])
self.add("ReactionWheel_Dynamics",
ReactionWheel_Dynamics(n, h),
promotes=['*'])
self.add("Solar_ExposedArea",
Solar_ExposedArea(n, solar_raw1, solar_raw2),
promotes=['*'])
self.add("Sun_LOS", Sun_LOS(n), promotes=['*'])
self.add("Sun_PositionBody", Sun_PositionBody(n), promotes=['*'])
self.add("Sun_PositionECI", Sun_PositionECI(n), promotes=['*'])
self.add("Sun_PositionSpherical",
Sun_PositionSpherical(n),
promotes=['*'])
self.add("ThermalTemperature",
ThermalTemperature(n, h),
promotes=['*'])
class TakeLast(Component):
def __init__(self):
super(TakeLast, self).__init__()
self.add_param('input', val=0.1)
self.add_output('output', val=0.1, pass_by_obj=True)
def solve_nonlinear(self, params, unknowns, resids):
unknowns['output'] = params['input'][-1]
if __name__ == "__main__":
top = Problem()
root = top.root = Group()
root.add('simprop', IndepVarComp('simtime', val="100"))
root.add('p1', IndepVarComp('rho', val=1.0))
root.add('p2', IndepVarComp('jturbine', val=1.0))
root.add('p3', IndepVarComp('ratio', val=1.0))
root.add(
'modelica',
OMModelWrapper(
'WindPowerPlants.Examples.GenericPlantRayleigh',
'/Users/adam/repo/WindPowerPlants/WindPowerPlants/package.mo'))
root.add('tl_peakPowerOutput', TakeLast())
root.add('tl_integratedEnergy', TakeLast())
top.driver = UniformDriver(5000)
top.driver.add_desvar('p1.rho', low=1.0, high=1.5)
top.driver.add_desvar('p2.jturbine',
low=13000000 * 0.7,
if 'petsc' in sys.argv:
from openmdao.core.petsc_impl import PetscImpl
impl = PetscImpl
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)
def test_param_vec(self):
top = Problem()
top.root = Group()
top.root.add('comp', ArrayComp2D(), promotes=['x', 'y'])
top.root.add('p1',
IndepVarComp('x', np.array([[1.0, 2.0], [3.0, 4.0]])),
promotes=['x'])
top.root.add('comp2', SimpleComp())
top.root.add('p2', IndepVarComp('x', 3.0))
top.root.connect('p2.x', 'comp2.x')
top.setup(check=False)
top.run()
params = ComplexStepTgtVecWrapper(top.root.comp.params)
# Get a param that isn't complex-stepped
x = params['x']
self.assertTrue(x.dtype == np.float)
self.assertEquals(x[0, 1], 2.0)
# Get a param that is now complex
params.set_complex_var('x')
x = params['x']
self.assertTrue(x.dtype == np.complex)
self.assertEquals(x[0, 1], 2.0 + 0j)
# Apply complex step and get param
params.step_complex(1, 4.0)
x = params['x']
self.assertEquals(x[0, 1], 2.0 + 4j)
# Unset complex
params.set_complex_var(None)
x = params['x']
self.assertEquals(x[0, 1], 2.0)
params = ComplexStepTgtVecWrapper(top.root.comp2.params)
# Get a param that isn't complex-stepped
x = params['x']
self.assertTrue(x.dtype == np.float)
self.assertEquals(x, 3.0)
# Get a param that is now complex
params.set_complex_var('x')
x = params['x']
self.assertTrue(x.dtype == np.complex)
self.assertEquals(x, 3.0 + 0j)
# Apply complex step and get param
params.step_complex(0, 4.0)
self.assertEquals(x, 3.0 + 4j)
# Make sure all other functions work for coverage
self.assertEquals(len(params), 1)
self.assertTrue('x' in params)
plist = [z for z in params]
self.assertEquals(plist, ['x'])
self.assertEquals(params.keys(), top.root.comp2.params.keys())
self.assertEquals(params.metadata('x'),
top.root.comp2.params.metadata('x'))
plist1 = [z for z in params.iterkeys()]
plist2 = [z for z in top.root.comp2.params.iterkeys()]
