def __init__(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# pylint: disable-msg=E1101
super(SellarBroyden, self).__init__()
# create solver instance
self.add('driver', BroydenSolver())
self.add('dis1', SellarDiscipline1())
self.add('dis2', SellarDiscipline2())
self.driver.workflow.add(['dis1', 'dis2'])
self.connect('dis1.y1', 'dis2.y1')
# solver connections
self.driver.add_parameter('dis1.y2', low=-9.e99, high=9.e99)
self.driver.add_constraint('dis2.y2 = dis1.y2')
self.driver.itmax = 10
self.driver.alpha = .4
self.driver.tol = .000000001
def configure(self):
compress = self.add('compress', CompressionSystem())
self.connect('Mach_pod', 'compress.Mach_pod')
self.connect('radius_tube', 'compress.radius_tube')
self.connect('Ps_tube', 'compress.Ps_tube')
self.connect('Ts_tube', 'compress.Ts_tube')
self.create_passthrough('compress.Mach_c1_in')
inlet_geom = self.add('inlet_geom', InletGeom())
self.connect('compress.area_c1_in', 'inlet_geom.area_inlet')
kant = self.add('kant', KantrowitzLimit())
self.connect('Mach_pod', 'kant.Mach_pod')
self.connect('radius_tube', 'kant.radius_tube')
self.connect('Ps_tube', 'kant.Ps_tube')
self.connect('Ts_tube', 'kant.Ts_tube')
self.connect('inlet_geom.radius_outer', 'kant.radius_inlet')
battery = self.add('battery', Battery())
driver = self.add('driver',BroydenSolver())
driver.add_parameter('compress.W_in',low=-1e15,high=1e15)
driver.add_constraint('compress.W_in=kant.W_excess')
driver.workflow.add(['compress','inlet_geom','kant'])
def __init__(self):
""" Creates a new Assembly with this problem
root at (0,1)
"""
# pylint: disable-msg=E1101
super(MIMOBroyden, self).__init__()
# create solver instance
self.add('driver', BroydenSolver())
self.add('dis1', MIMOEquation())
self.driver.workflow.add(['dis1'])
# solver connections
self.driver.add_parameter('dis1.x1', low=-9.e99, high=9.e99)
self.driver.add_parameter('dis1.x2', low=-9.e99, high=9.e99)
self.driver.add_parameter('dis1.x3', low=-9.e99, high=9.e99)
self.driver.add_parameter('dis1.x4', low=-9.e99, high=9.e99)
self.driver.add_parameter('dis1.x5', low=-9.e99, high=9.e99)
self.driver.add_constraint('dis1.f1 = 0.0')
self.driver.add_constraint('dis1.f2 = 0.0')
self.driver.add_constraint('dis1.f3 = 0.0')
self.driver.add_constraint('dis1.f4 = 0.0')
self.driver.add_constraint('dis1.f5 = 0.0')
self.driver.itmax = 40
self.driver.alpha = .8
self.driver.tol = .000001
def test_single_comp_external_solve(self):
model = set_as_top(Assembly())
model.add('comp', MyComp_Deriv())
model.add('driver', BroydenSolver())
model.driver.workflow.add('comp')
model.driver.add_parameter('comp.x', low=-100, high=100)
model.driver.add_parameter('comp.y', low=-100, high=100)
model.driver.add_parameter('comp.z', low=-100, high=100)
model.driver.add_constraint('comp.res[0] = 0')
model.driver.add_constraint('comp.res[1] = 0')
model.driver.add_constraint('comp.res[2] = 0')
model.comp.eval_only = True
self.assertEqual(set(model.driver.workflow.get_implicit_info()), set())
model.run()
assert_rel_error(self, model.comp.x, 1.0, 1e-5)
assert_rel_error(self, model.comp.y, -2.33333333, 1e-5)
assert_rel_error(self, model.comp.z, -2.16666667, 1e-5)
assert_rel_error(self, model.comp.y_out, -1.5, 1e-5)
def test_coupled_comps_internal_solve(self):
model = set_as_top(Assembly())
model.add('comp1', Coupled1())
model.add('comp2', Coupled2())
model.add('driver', BroydenSolver())
model.driver.workflow.add(['comp1', 'comp2'])
model.comp1.eval_only = False
model.comp2.eval_only = False
model.comp1.force_fd = False
model.comp2.force_fd = False
#model.connect('comp1.x', 'comp2.x')
#model.connect('comp1.y', 'comp2.y')
#model.connect('comp2.z', 'comp1.z')
model.driver.add_parameter('comp1.z', low=-100, high=100)
model.driver.add_parameter('comp2.x', low=-100, high=100)
model.driver.add_parameter('comp2.y', low=-100, high=100)
model.driver.add_constraint('comp1.z = comp2.z')
model.driver.add_constraint('comp2.x = comp1.x')
model.driver.add_constraint('comp2.y = comp1.y')
model.driver.tol
model.run()
assert_rel_error(self, model.comp1.x, 1.0, 1e-5)
assert_rel_error(self, model.comp1.y, -2.33333333, 1e-5)
assert_rel_error(self, model.comp2.z, -2.16666667, 1e-5)
assert_rel_error(self, model.comp1.y_out, -1.5, 1e-5)
def configure(self):
hx = self.add('hx', HeatExchanger())
driver = self.add('driver',BroydenSolver())
driver.add_parameter('hx.T_hot_out',low=0.,high=1000.)
driver.add_parameter('hx.T_cold_out',low=0.,high=1000.)
driver.add_constraint('hx.residual_qmax=0')
driver.add_constraint('hx.residual_e_balance=0')
#hx.Wh = 0.49
#hx.Cp_hot = 1.006
#hx.T_hot_in = 791
fs = FlowStation()
fs.setTotalTP(1423.8, 0.302712118187) #R, psi
fs.W = .49
hx.Fl_I = fs
hx.W_cold = 0.45
hx.Cp_cold = 4.186
hx.T_cold_in = 288.15
effectiveness = 0.9765
#initial guess
avg = ( hx.Fl_I.Tt*.555555556 + hx.T_cold_in )/2.
hx.T_cold_out = avg
hx.T_hot_out = avg
driver.workflow.add(['hx'])
def configure(self):
tm = self.add('tm', TubeWallTemp())
#tm.bearing_air.setTotalTP()
driver = self.add('driver',BroydenSolver())
driver.add_parameter('tm.temp_boundary',low=0.,high=10000.)
driver.add_constraint('tm.ss_temp_residual=0')
driver.workflow.add(['tm'])
def test_derivative_nested_solver(self):
model = set_as_top(Assembly())
model.add('comp', MyComp_Deriv())
model.add('solver', BroydenSolver())
model.driver.workflow.add('solver')
model.solver.workflow.add('comp')
model.solver.tol = 0.0000001
model.solver.add_parameter('comp.x', low=-100, high=100)
model.solver.add_parameter('comp.y', low=-100, high=100)
model.solver.add_parameter('comp.z', low=-100, high=100)
model.solver.add_constraint('comp.res[0] = 0')
model.solver.add_constraint('comp.res[1] = 0')
model.solver.add_constraint('comp.res[2] = 0')
model.comp.eval_only = True
model.run()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'])
edges = model.driver.workflow._edges
# print edges
self.assertEqual(edges['@in0'], ['comp.c'])
self.assertEqual(edges['comp.y_out'], ['@out0'])
self.assertEqual(edges['comp.res[0]'], ['_pseudo_0.in0'])
self.assertEqual(edges['comp.res[1]'], ['_pseudo_1.in0'])
self.assertEqual(edges['comp.res[2]'], ['_pseudo_2.in0'])
self.assertTrue(
'_pseudo_0.out0' in model.driver.workflow._derivative_graph)
self.assertTrue(
'_pseudo_1.out0' in model.driver.workflow._derivative_graph)
self.assertTrue(
'_pseudo_2.out0' in model.driver.workflow._derivative_graph)
self.assertTrue('comp.x' in model.driver.workflow._derivative_graph)
self.assertTrue('comp.y' in model.driver.workflow._derivative_graph)
self.assertTrue('comp.z' in model.driver.workflow._derivative_graph)
# print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'],
mode='adjoint')
# print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'],
mode='fd')
# print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
def __init__(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# pylint: disable-msg=E1101
super(SellarMDF, self).__init__()
# create Optimizer instance
self.add('driver', CONMINdriver())
# Outer Loop - Global Optimization
self.add('solver', BroydenSolver())
self.driver.workflow.add('solver')
# Inner Loop - Full Multidisciplinary Solve via fixed point iteration
self.add('dis1', sellar.Discipline1())
self.add('dis2', sellar.Discipline2())
self.solver.workflow.add(['dis1', 'dis2'])
# Make all connections
self.connect('dis1.y1','dis2.y1')
# Iteration loop
self.solver.add_parameter('dis1.y2', low=-9.e99, high=9.e99)
self.solver.add_constraint('dis2.y2 = dis1.y2')
# equivilent form
# self.solver.add_constraint('dis2.y2 - dis1.y2 = 0')
#Driver Settings
self.solver.itmax = 10
self.solver.alpha = .4
self.solver.tol = .0000001
self.solver.algorithm = "broyden2"
# Optimization parameters
self.driver.add_objective('(dis1.x1)**2 + dis1.z2 + dis1.y1 + math.exp(-dis2.y2)')
for param, low, high in zip([('dis1.z1','dis2.z1'), ('dis1.z2','dis2.z2'),
'dis1.x1'],
[-10.0, 0.0, 0.0],
[10.0, 10.0, 10.0]):
self.driver.add_parameter(param, low=low, high=high)
map(self.driver.add_constraint, ['3.16 < dis1.y1',
'dis2.y2 < 24.0' ])
self.driver.cons_is_linear = [1, 1]
self.driver.iprint = 0
self.driver.itmax = 30
self.driver.fdch = .001
self.driver.fdchm = .001
self.driver.delfun = .0001
self.driver.dabfun = .000001
self.driver.ctlmin = 0.0001
def configure(self):
# create solver instance
self.add('driver', BroydenSolver())
self.add('dis1', DumbComp())
self.driver.workflow.add(['dis1'])
# solver connections
self.driver.add_parameter('dis1.x1', low=-9.e99, high=9.e99)
self.driver.add_constraint('dis1.f1 = 0.0')
def test_medium_coupled(self):
self.top = set_as_top(Assembly())
exp0 = ['y=x']
deriv0 = ['dy_dx = 1.0']
exp1 = ['y2 = 0.5*sin(x1) - 0.5*x1*y1']
deriv1 = ['dy2_dx1 = 0.5*cos(x1) - 0.5*y1', 'dy2_dy1 = -0.5*x1']
exp2 = ['y1 = x2*x2*y2']
deriv2 = ['dy1_dx2 = 2.0*y2*x2', 'dy1_dy2 = x2*x2']
exp4 = ['y=3.0*x']
deriv4 = ['dy_dx = 3.0']
self.top.add('driver', Driv())
self.top.add('comp0', ExecCompWithDerivatives(exp0, deriv0))
self.top.add('comp1', ExecCompWithDerivatives(exp1, deriv1))
self.top.add('comp2', ExecCompWithDerivatives(exp2, deriv2))
self.top.add('comp3', ExecCompWithDerivatives(exp4, deriv4))
#self.top.add('comp1', ExecComp(exp1))
#self.top.add('comp2', ExecComp(exp2))
self.top.add('solver', BroydenSolver())
self.top.driver.workflow.add(['solver'])
self.top.solver.workflow.add(['comp0', 'comp1', 'comp2', 'comp3'])
self.top.connect('comp0.y', 'comp1.x1')
self.top.connect('comp1.y2', 'comp2.y2')
self.top.connect('comp2.y1', 'comp3.x')
# Solver setup
self.top.solver.add_parameter('comp1.y1', low=-1.e99, high=1.e99)
self.top.solver.add_constraint('comp2.y1 = comp1.y1')
# Top driver setup
#self.top.driver.differentiator = FiniteDifference()
self.top.driver.differentiator = Analytic()
obj = 'comp3.y'
self.top.driver.add_parameter('comp0.x',
low=-100.,
high=100.,
fd_step=.001)
self.top.driver.add_objective(obj)
self.top.comp0.x = 1.0
self.top.comp2.x2 = 1.0
self.top.run()
self.top.driver.differentiator.calc_gradient()
grad = self.top.driver.differentiator.get_gradient(obj)
assert_rel_error(self, grad[0], 3.0 * 0.08660, .001)
def test_derivative_state_connection_external_solve_ProvideJ(self):
model = set_as_top(Assembly())
model.add('comp', MyComp_Deriv_ProvideJ())
model.comp.add('c', Float(2.0, iotype="in", fd_step=.001))
model.add('comp2', ExecCompWithDerivatives(["y=2*x"], ["dy_dx=2"]))
model.add('solver', BroydenSolver())
model.solver.workflow.add(['comp', 'comp2'])
model.driver.workflow.add(['solver'])
model.connect('comp.z', 'comp2.x')
model.solver.add_parameter('comp.x', low=-100, high=100)
model.solver.add_parameter('comp.y', low=-100, high=100)
model.solver.add_parameter('comp.z', low=-100, high=100)
model.solver.add_constraint('comp.res[0] = 0')
model.solver.add_constraint('comp.res[1] = 0')
model.solver.add_constraint('comp.res[2] = 0')
model.comp.eval_only = True
model.run()
# print model.comp.x, model.comp.y, model.comp.z, model.comp.res
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp2.y'])
info = model.driver.workflow.get_implicit_info()
# print info
self.assertEqual(
set(info[('_pseudo_0.out0', '_pseudo_1.out0', '_pseudo_2.out0')]),
set([('comp.x', ), ('comp.y', ), ('comp.z', )]))
self.assertEqual(len(info), 1)
edges = model.driver.workflow._edges
# print edges
self.assertEqual(set(edges['@in0']), set(['comp.c']))
self.assertEqual(set(edges['comp2.y']), set(['@out0']))
assert_rel_error(self, J[0][0], -0.1666, 1e-3)
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp2.y'],
mode='adjoint')
assert_rel_error(self, J[0][0], -0.1666, 1e-3)
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp2.y'],
mode='fd')
assert_rel_error(self, J[0][0], -0.1666, 1e-3)
def configure(self):
""" Creates counter new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# create Optimizer instance
self.add('driver', SLSQPdriver())
# Outer Loop - Global Optimization
# self.add('solver', FixedPointIterator())
self.add('solver', BroydenSolver())
self.driver.workflow.add(['solver'])
# Inner Loop - Full Multidisciplinary Solve via fixed point iteration
self.add('dis1', sellar.Discipline1())
self.add('dis2', sellar.Discipline2())
self.solver.workflow.add(['dis1', 'dis2'])
# Add Parameters to optimizer
self.driver.add_parameter(('dis1.z1', 'dis2.z1'), low=-10.0, high=10.0)
self.driver.add_parameter(('dis1.z2', 'dis2.z2'), low=0.0, high=10.0)
self.driver.add_parameter('dis1.x1', low=0.0, high=10.0)
# Make all connections
self.connect('dis1.y1', 'dis2.y1')
# Iteration loop
self.solver.add_parameter('dis1.y2', low=-9.e99, high=9.e99)
self.solver.add_constraint('dis2.y2 = dis1.y2')
# self.solver.max_iteration = 100
# self.solver.tolerance = 0.00001
self.solver.itmax = 10
self.solver.alpha = .4
self.solver.tol = .0000001
self.solver.algorithm = "broyden2"
# Optimization parameters
self.driver.add_objective(
'(dis1.x1)**2 + dis1.z2 + dis1.y1 + math.exp(-dis2.y2)')
self.driver.add_constraint('3.16 < dis1.y1')
# Or use any of the equivalent forms below
# self.driver.add_constraint('3.16 - dis1.y1 < 0')
# self.driver.add_constraint('3.16 < dis1.y1')
# self.driver.add_constraint('-3.16 > -dis1.y1')
self.driver.add_constraint('dis2.y2 < 24.0')
def test_solver_nested_under_double_nested_driver_no_deriv(self):
model = set_as_top(Assembly())
model.add('comp', MyComp_No_Deriv())
model.add('subdriver', SimpleDriver())
model.add('solver', BroydenSolver())
model.driver.workflow.add('subdriver')
model.subdriver.workflow.add('solver')
model.solver.workflow.add('comp')
model.solver.tol = 0.0000001
model.solver.add_parameter('comp.x', low=-100, high=100)
model.solver.add_parameter('comp.y', low=-100, high=100)
model.solver.add_parameter('comp.z', low=-100, high=100)
model.solver.add_constraint('comp.res[0] = 0')
model.solver.add_constraint('comp.res[1] = 0')
model.solver.add_constraint('comp.res[2] = 0')
model.subdriver.add_parameter('comp.c', low=-100, high=100)
model.subdriver.add_objective('comp.y_out')
model.comp.eval_only = True
model.run()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'])
edges = model.driver.workflow._edges
# print edges
self.assertEqual(edges['@in0'], ['~subdriver.comp|c'])
self.assertEqual(edges['~subdriver.comp|y_out'], ['@out0'])
# print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'],
mode='adjoint')
# print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
model.driver.workflow.config_changed()
J = model.driver.workflow.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'],
mode='fd')
# print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
def configure(self):
"""Setup an MDF architecture inside this assembly.
"""
#create the top level optimizer
self.parent.add("driver", SLSQPdriver())
self.parent.driver.differentiator = FiniteDifference()
self.parent.driver.iprint = 0
self.parent.driver.recorders = self.data_recorders
params = self.parent.get_parameters()
global_dvs = []
local_dvs = []
for k, v in self.parent.get_global_des_vars():
global_dvs.append(v)
# and add the broadcast parameters to the driver
self.parent.driver.add_parameter(v, name=k)
for k, v in self.parent.get_local_des_vars():
local_dvs.append(v)
self.parent.driver.add_parameter(v, name=k)
#TODO: possibly add method for passing constraint directly?
#add the constraints to the driver
for const in self.parent.list_constraints():
self.parent.driver.add_constraint(const)
#set the global objective
objective = self.parent.get_objectives().items()[0]
self.parent.driver.add_objective(objective[1].text, name=objective[0])
#setup the inner loop solver
self.parent.add('solver', BroydenSolver())
self.parent.solver.itmax = 10
self.parent.solver.alpha = .4
self.parent.solver.tol = .0000001
self.parent.solver.algorithm = "broyden2"
#add the coupling vars parameters/constraints to the solver
for key, couple in self.parent.get_coupling_vars().iteritems():
self.parent.solver.add_parameter(couple.indep.target,
low=-1.e99,
high=1.e99,
name=key)
self.parent.solver.add_constraint(
"%s=%s" % (couple.indep.target, couple.dep.target))
#setup the workflows
self.parent.driver.workflow.add(['solver'])
def configure(self):
""" Creates a new Assembly with this problem
root at (0,1)
"""
# create solver instance
self.add('driver', BroydenSolver())
self.add('dis1', MIMOEquation())
self.driver.workflow.add(['dis1'])
# solver connections
self.driver.itmax = 40
self.driver.alpha = .8
self.driver.tol = .000001
def configure(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# pylint: disable-msg=E1101
# create Optimizer instance
self.add('driver', SLSQPdriver())
#Outer Loop - Global Optimization
self.add('solver', BroydenSolver())
self.driver.workflow.add(['solver'])
# Inner Loop - Full Multidisciplinary Solve via fixed point iteration
self.add('dis1', sellar.Discipline1())
self.add('dis2', sellar.Discipline2())
self.solver.workflow.add(['dis1', 'dis2'])
# Add Parameters to optimizer
self.driver.add_parameter(('dis1.z1', 'dis2.z1'), low=-10.0, high=10.0)
self.driver.add_parameter(('dis1.z2', 'dis2.z2'), low=0.0, high=10.0)
self.driver.add_parameter('dis1.x1', low=0.0, high=10.0)
# Make all connections
self.connect('dis1.y1', 'dis2.y1')
# Solver Iteration loop
self.solver.add_parameter('dis1.y2')
self.solver.add_constraint('dis2.y2 = dis1.y2')
# equivilent form
# self.solver.add_constraint('dis2.y2 - dis1.y2 = 0')
#Driver Settings
self.solver.itmax = 10
self.solver.alpha = .4
self.solver.tol = .0000001
self.solver.algorithm = "broyden2"
# Optimization parameters
self.driver.add_objective(
'(dis1.x1)**2 + dis1.z2 + dis1.y1 + math.exp(-dis2.y2)')
self.driver.add_constraint('3.16 < dis1.y1')
self.driver.add_constraint('dis2.y2 < 24.0')
self.driver.iprint = 0
def test_simple_coupled_adjoint(self):
self.top = set_as_top(Assembly())
exp1 = ['y2 = 0.5*sin(x1) - 0.5*x1*y1']
deriv1 = ['dy2_dx1 = 0.5*cos(x1) - 0.5*y1', 'dy2_dy1 = -0.5*x1']
exp2 = ['y1 = x2*x2*y2']
deriv2 = ['dy1_dx2 = 2.0*y2*x2', 'dy1_dy2 = x2*x2']
self.top.add('driver', Driv())
self.top.add('comp1', ExecCompWithDerivatives(exp1, deriv1))
self.top.add('comp2', ExecCompWithDerivatives(exp2, deriv2))
#self.top.add('comp1', ExecComp(exp1))
#self.top.add('comp2', ExecComp(exp2))
self.top.add('solver', BroydenSolver())
self.top.driver.workflow.add(['solver'])
self.top.solver.workflow.add(['comp1', 'comp2'])
self.top.connect('comp1.y2', 'comp2.y2')
# Solver setup
self.top.solver.add_parameter('comp1.y1', low=-1.e99, high=1.e99)
self.top.solver.add_constraint('comp2.y1 = comp1.y1')
# Top driver setup
self.top.driver.differentiator = Analytic()
self.top.driver.differentiator.mode = 'adjoint'
obj = 'comp2.y1'
self.top.driver.add_parameter('comp1.x1',
low=-100.,
high=100.,
fd_step=.001)
self.top.driver.add_parameter('comp2.x2',
low=-100.,
high=100.,
fd_step=.0001)
self.top.driver.add_objective(obj)
self.top.comp1.x1 = 1.0
self.top.comp2.x2 = 1.0
self.top.run()
self.top.driver.differentiator.calc_gradient()
grad = self.top.driver.differentiator.get_gradient(obj)
assert_rel_error(self, grad[0], 0.08660, .001)
def test_mass_flow_iter(self):
a = set_as_top(Assembly())
start = a.add('start', FlowStart())
ref = a.add('ref', FlowStart())
nozzle = a.add('nozzle', Nozzle())
start.W = 100.
start.Tt = 700.
start.Pt = 50.0
start.Mach = 0.40
ref.W = 1.0
ref.Tt = 518.67
ref.Pt = 15.0
ref.Mach = 0.0
a.connect('start.Fl_O', 'nozzle.Fl_I')
a.connect('ref.Fl_O', 'nozzle.Fl_ref')
a.add('design', Run_Once())
a.design.workflow.add(['start', 'ref', 'nozzle'])
a.design.add_event('start.design')
a.design.add_event('ref.design')
a.design.add_event('nozzle.design')
a.design.run()
a.add('off_design', BroydenSolver())
a.off_design.workflow.add(['start', 'ref', 'nozzle'])
a.off_design.add_parameter('start.W', low=-1e15, high=1e15)
a.off_design.add_constraint('nozzle.WqAexit=nozzle.WqAexit_dmd')
TOL = .001
ref.Pt = 39.0
a.off_design.run()
self.assertEqual(nozzle.switchRegime, 'UNCHOKED')
assert_rel_error(self, nozzle.Fl_O.W, 96.03, TOL)
assert_rel_error(self, nozzle.Fl_O.Mach, 0.607, TOL)
# set W = 80.80, MN throat = 0.562, MN exit = 0.470
ref.Pt = 43.0
a.off_design.run()
self.assertEqual(nozzle.switchRegime, 'UNCHOKED')
assert_rel_error(self, nozzle.Fl_O.W, 80.80, TOL)
assert_rel_error(self, nozzle.Fl_O.Mach, 0.470, TOL)
def __init__(self):
""" A new do-nothing assembly
"""
# pylint: disable-msg=E1101
super(DumbAssembly, self).__init__()
# create solver instance
self.add('driver', BroydenSolver())
self.add('dis1', DumbComp())
self.driver.workflow.add(['dis1'])
# solver connections
self.driver.add_parameter('dis1.x1', low=-9.e99, high=9.e99)
self.driver.add_constraint('dis1.f1 = 0.0')
def test_derivative_state_connection_external_solve_ProvideJ(self):
model = set_as_top(Assembly())
model.add('driver', SimpleDriver())
model.add('comp', MyComp_Deriv_ProvideJ())
model.comp.add('c', Float(2.0, iotype="in", fd_step=.001))
model.add('comp2', ExecCompWithDerivatives(["y=2*x"], ["dy_dx=2"]))
model.add('solver', BroydenSolver())
model.solver.workflow.add(['comp', 'comp2'])
model.driver.workflow.add(['solver'])
model.connect('comp.z', 'comp2.x')
model.solver.add_parameter('comp.x', low=-100, high=100)
model.solver.add_parameter('comp.y', low=-100, high=100)
model.solver.add_parameter('comp.z', low=-100, high=100)
model.solver.add_constraint('comp.res[0] = 0')
model.solver.add_constraint('comp.res[1] = 0')
model.solver.add_constraint('comp.res[2] = 0')
model.comp.eval_only = True
model.run()
#print model.comp.x, model.comp.y, model.comp.z, model.comp.res
J = model.driver.calc_gradient(inputs=['comp.c'],
outputs=['comp2.y'],
mode='forward')
assert_rel_error(self, J[0][0], -0.1666, 2e-3)
J = model.driver.calc_gradient(inputs=['comp.c'],
outputs=['comp2.y'],
mode='adjoint')
assert_rel_error(self, J[0][0], -0.1666, 2e-3)
J = model.driver.calc_gradient(inputs=['comp.c'],
outputs=['comp2.y'],
mode='fd')
assert_rel_error(self, J[0][0], -0.1666, 2e-3)
def configure(self):
hx = self.add('hx', HeatExchanger())
driver = self.add('driver',BroydenSolver())
driver.add_parameter('hx.T_hot_out',low=0.,high=1000.)
driver.add_parameter('hx.T_cold_out',low=0.,high=1000.)
driver.add_constraint('hx.residual_qmax=0')
driver.add_constraint('hx.residual_e_balance=0')
#hx.Wh = 0.49
#hx.Cp_hot = 1.006
#hx.T_hot_in = 791
fs = FlowStation()
fs.setTotalTP(1423.8, 0.302712118187) #R, psi
fs.W = 1.0
hx.Fl_I = fs
hx.W_cold = .45
hx.T_hot_out = hx.Fl_I.Tt
hx.T_cold_out = hx.T_cold_in
driver.workflow.add(['hx'])
def test_AAAinitial_run(self):
# The reason for putting the AAA in the name is so it runs
# first. We should have to do that. There is some kind
# of testing bug that is forcing us to do that
# Test the fix that peforms an initial run
# at the top of the execute method
class MyComp(Component):
x = Float(0.0, iotype='in', low=-100000, high=100000)
xx = Float(0.0, iotype='in', low=-100000, high=100000)
f_x = Float(iotype='out')
y = Float(iotype='out')
def execute(self):
if self.xx != 1.0:
self.raise_exception("Lazy", RuntimeError)
self.f_x = 2.0 * self.x
self.y = self.x
@add_delegate(HasParameters)
class SpecialDriver(Driver):
implements(IHasParameters)
def execute(self):
self.set_parameters([1.0])
self.prob = set_as_top(Assembly())
self.prob.add('comp', MyComp())
self.prob.add('driver', BroydenSolver())
self.prob.add('subdriver', SpecialDriver())
self.prob.driver.workflow.add('subdriver')
self.prob.subdriver.workflow.add('comp')
self.prob.subdriver.add_parameter('comp.xx')
self.prob.driver.add_parameter('comp.x')
self.prob.driver.add_constraint('comp.y = comp.x')
print "initial run test"
self.prob.run()
def test_derivative_nested_solver_no_deriv(self):
model = set_as_top(Assembly())
model.add('driver', SimpleDriver())
model.add('comp', MyComp_No_Deriv())
model.add('solver', BroydenSolver())
model.driver.workflow.add('solver')
model.solver.workflow.add('comp')
model.solver.tol = 0.0000001
model.solver.add_parameter('comp.x', low=-100, high=100)
model.solver.add_parameter('comp.y', low=-100, high=100)
model.solver.add_parameter('comp.z', low=-100, high=100)
model.solver.add_constraint('comp.res[0] = 0')
model.solver.add_constraint('comp.res[1] = 0')
model.solver.add_constraint('comp.res[2] = 0')
model.comp.eval_only = True
model.run()
J = model.driver.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'])
#print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
J = model.driver.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'],
mode='adjoint')
#print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
J = model.driver.calc_gradient(inputs=['comp.c'],
outputs=['comp.y_out'],
mode='fd')
#print J
assert_rel_error(self, J[0][0], 0.75, 1e-5)
def configure(self):
hx = self.add('hx', heat_exchanger.HeatExchanger())
driver = self.add('driver', BroydenSolver())
driver.add_parameter('hx.T_hot_out', low=0., high=1000.)
driver.add_parameter('hx.T_cold_out', low=0., high=1000.)
driver.add_constraint('hx.residual_qmax=0')
driver.add_constraint('hx.residual_e_balance=0')
#hx.Wh = 0.49
#hx.Cp_hot = 1.006
#hx.T_hot_in = 791
fs = flowstation.FlowStation()
fs.setTotalTP(1423.8, 0.302712118187) #R, psi
fs.W = 1.0
hx.Fl_I = fs
hx.dpQp = 0.0
#initial guess
avg = (hx.Fl_I.Tt + hx.T_cold_in) / 2.
hx.T_cold_out = avg
hx.T_hot_out = avg
driver.workflow.add(['hx'])
def configure(self):
#Add Components
compress = self.add('compress', CompressionSystem())
mission = self.add('mission', Mission())
pod = self.add('pod', Pod())
flow_limit = self.add('flow_limit', TubeLimitFlow())
tube_wall_temp = self.add('tube_wall_temp', TubeWallTemp())
#Boundary Input Connections
#Hyperloop -> Compress
self.connect('Mach_pod_max', 'compress.Mach_pod_max')
self.connect('Ps_tube', 'compress.Ps_tube')
self.connect('Mach_c1_in', 'compress.Mach_c1_in') #Design Variable
self.connect('c1_PR_des', 'compress.c1_PR_des') #Design Variable
#Hyperloop -> Mission
self.connect('tube_length', 'mission.tube_length')
self.connect('pwr_marg', 'mission.pwr_marg')
#Hyperloop -> Flow Limit
self.connect('Mach_pod_max', 'flow_limit.Mach_pod')
self.connect('Ps_tube', 'flow_limit.Ps_tube')
self.connect('pod.radius_inlet_back_outer', 'flow_limit.radius_inlet')
self.connect('Mach_bypass', 'flow_limit.Mach_bypass')
#Hyperloop -> Pod
self.connect('Ps_tube', 'pod.Ps_tube')
self.connect('hub_to_tip', 'pod.hub_to_tip')
self.connect('coef_drag', 'pod.coef_drag')
self.connect('n_rows', 'pod.n_rows')
self.connect('length_row', 'pod.length_row')
#Hyperloop -> TubeWallTemp
self.connect('solar_heating_factor',
'tube_wall_temp.nn_incidence_factor')
self.connect('tube_length', 'tube_wall_temp.length_tube')
#Inter-component Connections
#Compress -> Mission
self.connect('compress.speed_max', 'mission.speed_max')
self.connect('compress.pwr_req', 'mission.pwr_req')
#Compress -> Pod
self.connect('compress.area_c1_in', 'pod.area_inlet_out')
self.connect('compress.area_inlet_in', 'pod.area_inlet_in')
self.connect('compress.rho_air', 'pod.rho_air')
self.connect('compress.F_net', 'pod.F_net')
self.connect('compress.speed_max', 'pod.speed_max')
#Compress -> TubeWallTemp
self.connect('compress.nozzle_Fl_O', 'tube_wall_temp.nozzle_air')
self.connect('compress.bearing_Fl_O', 'tube_wall_temp.bearing_air')
#Mission -> Pod
self.connect('mission.time', 'pod.time_mission')
self.connect('mission.energy', 'pod.energy')
#Add Solver
solver = self.add('solver', BroydenSolver())
solver.itmax = 50 #max iterations
solver.tol = .001
#Add Parameters and Constraints
solver.add_parameter('compress.W_in', low=-1e15, high=1e15)
solver.add_parameter('compress.c2_PR_des', low=-1e15, high=1e15)
solver.add_parameter([
'compress.Ts_tube', 'flow_limit.Ts_tube',
'tube_wall_temp.temp_boundary'
],
low=-1e-15,
high=1e15)
solver.add_parameter(
['flow_limit.radius_tube', 'pod.radius_tube_inner'],
low=-1e15,
high=1e15)
solver.add_constraint('.01*(compress.W_in-flow_limit.W_excess) = 0')
solver.add_constraint('compress.Ps_bearing_residual=0')
solver.add_constraint('tube_wall_temp.ss_temp_residual=0')
solver.add_constraint(
'.01*(pod.area_compressor_bypass-compress.area_c1_out)=0')
driver = self.driver
driver.workflow.add('solver')
#driver.recorders = [CSVCaseRecorder(filename="hyperloop_data.csv")] #record only converged
#driver.printvars = ['Mach_bypass', 'Mach_pod_max', 'Mach_c1_in', 'c1_PR_des', 'pod.radius_inlet_back_outer',
# 'pod.inlet.radius_back_inner', 'flow_limit.radius_tube', 'compress.W_in', 'compress.c2_PR_des',
# 'pod.net_force', 'compress.F_net', 'compress.pwr_req', 'pod.energy', 'mission.time',
# 'compress.speed_max', 'tube_wall_temp.temp_boundary']
#Declare Solver Workflow
solver.workflow.add(
['compress', 'mission', 'pod', 'flow_limit', 'tube_wall_temp'])
def configure(self):
global_dvs = self.parent.get_global_des_vars()
local_dvs = self.parent.get_local_des_vars_by_comp()
objective = self.parent.get_objectives().items()[0]
constraints = self.parent.list_constraints()
coupling = self.parent.list_coupling_vars()
self.parent.add('driver', FixedPointIterator())
self.parent.driver.max_iteration = 50
self.parent.driver.tolerance = .005
#set initial values
for comp, param in global_dvs:
param.initialize(self.parent)
for comp, local_params in local_dvs.iteritems():
for param in local_params:
param.initialize(self.parent)
for couple in coupling.values():
couple.indep.set(couple.start)
initial_conditions = [param.start for comp, param in global_dvs]
self.parent.add_trait('global_des_vars',
Array(initial_conditions, iotype="in"))
for i, (comps, param) in enumerate(global_dvs):
targets = param.targets
self.parent.driver.add_parameter(targets,
low=param.low,
high=param.high,
start=param.start)
self.parent.driver.add_constraint("global_des_vars[%d]=%s" %
(i, targets[0]))
for comp, local_params in local_dvs.iteritems():
initial_conditions = [param.start for param in local_params]
self.parent.add_trait('%s_local_des_vars' % comp,
Array(initial_conditions, iotype="in"))
for i, param in enumerate(local_params):
self.parent.driver.add_parameter(param.targets,
low=param.low,
high=param.high,
start=param.start)
self.parent.driver.add_constraint('%s_local_des_vars[%d]=%s' %
(comp, i, param.targets[0]))
# Multidisciplinary Analysis
mda = self.parent.add('mda', BroydenSolver())
for couple in coupling.values():
mda.add_parameter(couple.indep.target)
mda.add_constraint("%s=%s" %
(couple.indep.target, couple.dep.target))
#Global Sensitivity Analysis
ssa = self.parent.add("ssa", SensitivityDriver())
ssa.workflow.add("mda")
ssa.default_stepsize = 1.0e-6
ssa.add_objective(objective[1].text, name=objective[0])
for comps, param in global_dvs:
ssa.add_parameter(param.targets, low=param.low, high=param.high)
for constraint in constraints:
ssa.add_constraint(constraint)
#discipline sensitivity analyses
sa_s = []
for comp, local_params in local_dvs.iteritems():
sa = self.parent.add('sa_%s' % comp, SensitivityDriver())
sa.default_stepsize = 1.0e-6
sa_s.append('sa_%s' % comp)
for param in local_params:
sa.add_parameter(param.targets,
low=param.low,
high=param.high,
fd_step=.001)
for constraint in constraints:
sa.add_constraint(constraint)
sa.add_objective(objective[1].text, name=objective[0])
#Linear System Optimizations
# Discipline Optimization
# (Only discipline1 has an optimization input)
bbopts = []
for comp, local_params in local_dvs.iteritems():
bbopt = self.parent.add('bbopt_%s' % comp, SLSQPdriver())
bbopt.iprint = 0
bbopts.append('bbopt_%s' % comp)
x_store = "%s_local_des_vars" % comp
delta_x = []
df = []
dg = []
for i, param in enumerate(local_params):
x_store_i = "%s[%d]" % (x_store, i)
bbopt.add_parameter(x_store_i,
low=param.low,
high=param.high,
start=param.start)
dx = "(%s-%s)" % (x_store_i, param.targets[0])
delta_x.append(dx)
#bbopt.add_constraint("%s < %f*%s" %(dx, .2, param.targets[0]))
#bbopt.add_constraint("%s > -%f*%s "%(dx, .2, param.targets[0]))
bbopt.add_constraint("%s < .5" % (dx, ))
bbopt.add_constraint("%s > -.5" % (dx, ))
df.append("sa_%s.dF[0][%d]*%s" % (comp, i, dx))
#build the linear constraint string for each constraint
for j, const in enumerate(constraints):
dg_j = [
"sa_%s.dG[%d][%d]*%s" % (comp, j, i, x)
for i, x in enumerate(delta_x)
]
constraint_parts = ["sa_%s.G[%d]" % (comp, j)]
constraint_parts.extend(dg_j)
lin_constraint = "%s < 0" % "+".join(constraint_parts)
bbopt.add_constraint(lin_constraint)
#build the linear objective string
objective_parts = ["sa_%s.F[0]" % comp]
objective_parts.extend(df)
lin_objective = "+".join(objective_parts)
bbopt.add_objective(lin_objective)
# Global Optimization
delta_z = []
df = []
dg = []
sysopt = self.parent.add('sysopt', SLSQPdriver())
sysopt.recorders = self.data_recorders
sysopt.iprint = 0
for i, (comps, param) in enumerate(global_dvs):
z_store = "global_des_vars[%d]" % i
target = list(param.targets)[0]
sysopt.add_parameter(z_store,
low=param.low,
high=param.high,
start=param.start)
dz = "(%s-%s)" % (z_store, target)
delta_z.append(dz)
#sysopt.add_constraint("%s < %f*%s" % (dz, .1, target))
#sysopt.add_constraint("%s > -%f*%s" % (dz, .1, target))
sysopt.add_constraint("%s < .5" % (dz, ))
sysopt.add_constraint("%s > -.5" % (dz, ))
df.append("ssa.dF[0][%d]*%s" % (i, dz))
dg_j = [
"ssa.dG[%d][%d]*%s" % (j, i, dz)
for j, const in enumerate(constraints)
]
dg.append(dg_j)
objective_parts = ["ssa.F[0]"]
objective_parts.extend(df)
lin_objective = "+".join(objective_parts)
sysopt.add_objective(lin_objective)
#build the linear constraint string for each constraint
for j, const in enumerate(constraints):
dg_j = [
"ssa.dG[%d][%d]*%s" % (j, i, x) for i, x in enumerate(delta_z)
]
constraint_parts = ["ssa.G[%d]" % j]
constraint_parts.extend(dg_j)
lin_constraint = "%s < 0" % "+".join(constraint_parts)
sysopt.add_constraint(lin_constraint)
#self.parent.driver.workflow.add("mda")
self.parent.driver.workflow.add(sa_s)
if global_dvs:
self.parent.driver.workflow.add("ssa")
self.parent.driver.workflow.add(bbopts)
if global_dvs:
self.parent.driver.workflow.add("sysopt")
def configure(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# Disciplines
self.add('dis1', sellar.Discipline1())
self.add('dis2', sellar.Discipline2())
objective = '(dis1.x1)**2 + dis1.z2 + dis1.y1 + exp(-dis2.y2)'
constraint1 = 'dis1.y1 > 3.16'
constraint2 = 'dis2.y2 < 24.0'
# Top level is Fixed-Point Iteration
self.add('driver', FixedPointIterator())
self.driver.add_parameter('dis1.x1', low=0.0, high=10.0, start=1.0)
self.driver.add_parameter(['dis1.z1', 'dis2.z1'],
low=-10.0,
high=10.0,
start=5.0)
self.driver.add_parameter(['dis1.z2', 'dis2.z2'],
low=0.0,
high=10.0,
start=2.0)
self.driver.add_constraint('x1_store = dis1.x1')
self.driver.add_constraint('z_store[0] = dis1.z1')
self.driver.add_constraint('z_store[1] = dis1.z2')
self.driver.max_iteration = 50
self.driver.tolerance = .001
# Multidisciplinary Analysis
self.add('mda', BroydenSolver())
self.mda.add_parameter('dis1.y2', low=-9.e99, high=9.e99, start=0.0)
self.mda.add_constraint('dis2.y2 = dis1.y2')
self.mda.add_parameter('dis2.y1', low=-9.e99, high=9.e99, start=3.16)
self.mda.add_constraint('dis2.y1 = dis1.y1')
# Discipline 1 Sensitivity Analysis
self.add('sa_dis1', SensitivityDriver())
self.sa_dis1.workflow.add(['dis1'])
self.sa_dis1.add_parameter('dis1.x1', low=0.0, high=10.0, fd_step=.001)
self.sa_dis1.add_constraint(constraint1)
self.sa_dis1.add_constraint(constraint2)
self.sa_dis1.add_objective(objective, name='obj')
# Discipline 2 Sensitivity Analysis
# dis2 has no local parameter, so there is no need to treat it as
# a subsystem.
# System Level Sensitivity Analysis
# Note, we cheat here and run an MDA instead of solving the
# GSE equations. Have to put this on the TODO list.
self.add('ssa', SensitivityDriver())
self.ssa.workflow.add(['mda'])
self.ssa.add_parameter(['dis1.z1', 'dis2.z1'], low=-10.0, high=10.0)
self.ssa.add_parameter(['dis1.z2', 'dis2.z2'], low=0.0, high=10.0)
self.ssa.add_constraint(constraint1)
self.ssa.add_constraint(constraint2)
self.ssa.add_objective(objective, name='obj')
# Discipline Optimization
# (Only discipline1 has an optimization input)
self.add('bbopt1', CONMINdriver())
self.bbopt1.add_parameter('x1_store', low=0.0, high=10.0, start=1.0)
self.bbopt1.add_objective(
'sa_dis1.F[0] + sa_dis1.dF[0][0]*(x1_store-dis1.x1)')
self.bbopt1.add_constraint(
'sa_dis1.G[0] + sa_dis1.dG[0][0]*(x1_store-dis1.x1) < 0')
#this one is technically unncessary
self.bbopt1.add_constraint(
'sa_dis1.G[1] + sa_dis1.dG[1][0]*(x1_store-dis1.x1) < 0')
self.bbopt1.add_constraint('(x1_store-dis1.x1)<.5')
self.bbopt1.add_constraint('(x1_store-dis1.x1)>-.5')
self.bbopt1.iprint = 0
self.bbopt1.linobj = True
# Global Optimization
self.add('sysopt', CONMINdriver())
self.sysopt.add_parameter('z_store[0]',
low=-10.0,
high=10.0,
start=5.0)
self.sysopt.add_parameter('z_store[1]', low=0.0, high=10.0, start=2.0)
self.sysopt.add_objective(
'ssa.F[0]+ ssa.dF[0][0]*(z_store[0]-dis1.z1) + ssa.dF[0][1]*(z_store[1]-dis1.z2)'
)
self.sysopt.add_constraint(
'ssa.G[0] + ssa.dG[0][0]*(z_store[0]-dis1.z1) + ssa.dG[0][1]*(z_store[1]-dis1.z2) < 0'
)
self.sysopt.add_constraint(
'ssa.G[1] + ssa.dG[1][0]*(z_store[0]-dis1.z1) + ssa.dG[1][1]*(z_store[1]-dis1.z2) < 0'
)
self.sysopt.add_constraint('z_store[0]-dis1.z1<.5')
self.sysopt.add_constraint('z_store[0]-dis1.z1>-.5')
self.sysopt.add_constraint('z_store[1]-dis1.z2<.5')
self.sysopt.add_constraint('z_store[1]-dis1.z2>-.5')
self.sysopt.iprint = 0
self.sysopt.linobj = True
self.driver.workflow.add(['ssa', 'sa_dis1', 'bbopt1', 'sysopt'])
def __init__(self):
super(Scalable, self).__init__()
#three components: d0,d1,d2
obj = "d0.z0**2+d0.z1**2+d0.z2**2+d0.y_out**2+d1.y_out**2+d2.y_out**2"
d0_const = "1-d0.y_out/c0 <= 0"
d1_const = "1-d1.y_out/c1 <= 0"
d2_const = "1-d2.y_out/c2 <= 0"
#initial MDA
mda = self.add("mda", BroydenSolver())
mda.add_parameter("d0.y_in0", low=-1e99, high=1e99)
mda.add_parameter("d0.y_in1", low=-1e99, high=1e99)
mda.add_constraint("d0.y_out=d1.y_in0")
mda.add_constraint("d0.y_out=d2.y_in0")
mda.add_parameter("d1.y_in0", low=-1e99, high=1e99)
mda.add_parameter("d1.y_in1", low=-1e99, high=1e99)
mda.add_constraint("d1.y_out=d0.y_in0")
mda.add_constraint("d1.y_out=d2.y_in1")
mda.add_parameter("d2.y_in0", low=-1e99, high=1e99)
mda.add_parameter("d2.y_in1", low=-1e99, high=1e99)
mda.add_constraint("d2.y_out=d0.y_in1")
mda.add_constraint("d2.y_out=d1.y_in1")
sa0 = self.add('sa0', SensitivityDriver())
sa0.differentiator = FiniteDifference()
sa0.add_parameter('d0.x0', low=-10, high=10)
sa0.add_parameter('d0.x1', low=-10, high=10)
sa0.add_parameter('d0.x2', low=-10, high=10)
sa0.add_objective(obj)
sa0.add_constraint(d0_const)
sa1 = self.add('sa1', SensitivityDriver())
sa1.differentiator = FiniteDifference()
sa1.add_parameter('d1.x0', low=-10, high=10)
sa1.add_parameter('d1.x1', low=-10, high=10)
sa1.add_parameter('d1.x2', low=-10, high=10)
sa1.add_objective(obj)
sa1.add_constraint(d1_const)
sa2 = self.add('sa2', SensitivityDriver())
sa2.differentiator = FiniteDifference()
sa2.add_parameter('d0.x0', low=-10, high=10)
sa2.add_parameter('d0.x1', low=-10, high=10)
sa2.add_parameter('d0.x2', low=-10, high=10)
sa2.add_objective(obj)
sa2.add_constraint(d2_const)
ssa = self.add('ssa', SensitivityDriver())
ssa.differentiator = FiniteDifference()
ssa.add_parameter(("d0.z0", "d1.z0", "d2.z0"), low=-10, high=10)
ssa.add_parameter(("d0.z1", "d1.z1", "d2.z1"), low=-10, high=10)
ssa.add_parameter(("d0.z2", "d1.z2", "d2.z2"), low=-10, high=10)
ssa.add_objective(obj)
ssa.add_constraint(d0_const)
ssa.add_constraint(d1_const)
ssa.add_constraint(d2_const)
bbopt0 = self.add('bbopt0', CONMINdriver())
bbopt0.add_parameter('d0_local_des_vars[0]', low=-10, high=10)
bbopt0.add_parameter('d0_local_des_vars[1]', low=-10, high=10)
bbopt0.add_parameter('d0_local_des_vars[2]', low=-10, high=10)
bbopt0.add_objective(
'sa0.F[0] + sa0.dF[0][0]*(d0_local_des_vars[0]-d0.x0)'
'+ sa0.dF[0][1]*(d0_local_des_vars[1]-d0.x1)'
'+ sa0.dF[0][2]*(d0_local_des_vars[2]-d0.x2)')
bbopt0.add_constraint(
'sa0.G[0] + sa0.dG[0][0]*(d0_local_des_vars[0]-d0.x0)'
'+ sa0.dG[0][1]*(d0_local_des_vars[1]-d0.x1)'
'+ sa0.dG[0][2]*(d0_local_des_vars[2]-d0.x2) <= 0')
bbopt0.add_constraint(
'(d0_local_des_vars[0]-d0.x0)<=(percent*d0.x0+.0001)*factor**(mda.exec_count-offset)'
)
bbopt0.add_constraint(
'(d0_local_des_vars[1]-d1.x1)<=(percent*d0.x1+.0001)*factor**(mda.exec_count-offset)'
)
bbopt0.add_constraint(
'(d0_local_des_vars[2]-d2.x2)<=(percent*d0.x2+.0001)*factor**(mda.exec_count-offset)'
)
bbopt0.add_constraint(
'(d0_local_des_vars[0]-d0.x0)>=(-percent*d0.x0-.0001)*factor**(mda.exec_count-offset)'
)
bbopt0.add_constraint(
'(d0_local_des_vars[1]-d1.x1)>=(-percent*d0.x1-.0001)*factor**(mda.exec_count-offset)'
)
bbopt0.add_constraint(
'(d0_local_des_vars[2]-d2.x2)>=(-percent*d0.x2-.0001)*factor**(mda.exec_count-offset)'
)
bbopt1 = self.add('bbopt1', CONMINdriver())
bbopt1.add_parameter('d1_local_des_vars[0]', low=-10, high=10)
bbopt1.add_parameter('d1_local_des_vars[1]', low=-10, high=10)
bbopt1.add_parameter('d1_local_des_vars[2]', low=-10, high=10)
bbopt1.add_objective(
'sa1.F[0] + sa1.dF[0][0]*(d1_local_des_vars[0]-d1.x0)'
'+ sa1.dF[0][1]*(d1_local_des_vars[1]-d1.x1)'
'+ sa1.dF[0][2]*(d1_local_des_vars[2]-d1.x2)')
bbopt1.add_constraint(
'sa1.G[0] + sa1.dG[0][0]*(d1_local_des_vars[0]-d1.x0)'
'+ sa1.dG[0][1]*(d1_local_des_vars[1]-d1.x1)'
'+ sa1.dG[0][2]*(d1_local_des_vars[2]-d1.x2) <= 0')
bbopt1.add_constraint(
'(d1_local_des_vars[0]-d1.x0)<=(percent*d1.x0+.0001)*factor**(mda.exec_count-offset)'
)
bbopt1.add_constraint(
'(d1_local_des_vars[1]-d1.x1)<=(percent*d1.x1+.0001)*factor**(mda.exec_count-offset)'
)
bbopt1.add_constraint(
'(d1_local_des_vars[2]-d1.x2)<=(percent*d1.x2+.0001)*factor**(mda.exec_count-offset)'
)
bbopt1.add_constraint(
'(d1_local_des_vars[0]-d1.x0)>=(-percent*d1.x0-.0001)*factor**(mda.exec_count-offset)'
)
bbopt1.add_constraint(
'(d1_local_des_vars[1]-d1.x1)>=(-percent*d1.x1-.0001)*factor**(mda.exec_count-offset)'
)
bbopt1.add_constraint(
'(d1_local_des_vars[2]-d1.x2)>=(-percent*d1.x2-.0001)*factor**(mda.exec_count-offset)'
)
bbopt2 = self.add('bbopt2', CONMINdriver())
bbopt2.add_parameter('d2_local_des_vars[0]', low=-10, high=10)
bbopt2.add_parameter('d2_local_des_vars[1]', low=-10, high=10)
bbopt2.add_parameter('d2_local_des_vars[2]', low=-10, high=10)
bbopt2.add_objective(
'sa2.F[0] + sa2.dF[0][0]*(d2_local_des_vars[0]-d2.x0)'
'+ sa2.dF[0][1]*(d2_local_des_vars[1]-d2.x1)'
'+ sa2.dF[0][2]*(d2_local_des_vars[2]-d2.x2)')
bbopt2.add_constraint(
'sa2.G[0] + sa2.dG[0][0]*(d2_local_des_vars[0]-d2.x0)'
'+ sa2.dG[0][1]*(d2_local_des_vars[1]-d2.x1)'
'+ sa2.dG[0][2]*(d2_local_des_vars[2]-d2.x2) <= 0')
bbopt2.add_constraint(
'(d2_local_des_vars[0]-d2.x0)<=(percent*d2.x0+.0001)*factor**(mda.exec_count-offset)'
)
bbopt2.add_constraint(
'(d2_local_des_vars[1]-d2.x1)<=(percent*d2.x1+.0001)*factor**(mda.exec_count-offset)'
)
bbopt2.add_constraint(
'(d2_local_des_vars[2]-d2.x2)<=(percent*d2.x2+.0001)*factor**(mda.exec_count-offset)'
)
bbopt2.add_constraint(
'(d2_local_des_vars[0]-d2.x0)>=(-percent*d2.x0-.0001)*factor**(mda.exec_count-offset)'
)
bbopt2.add_constraint(
'(d2_local_des_vars[1]-d2.x1)>=(-percent*d2.x1-.0001)*factor**(mda.exec_count-offset)'
)
bbopt2.add_constraint(
'(d2_local_des_vars[2]-d2.x2)>=(-percent*d2.x2-.0001)*factor**(mda.exec_count-offset)'
)
sysopt = self.add('sysopt', CONMINdriver())
sysopt.add_parameter('global_des_vars[0]', low=-10, high=10)
sysopt.add_parameter('global_des_vars[1]', low=-10, high=10)
sysopt.add_parameter('global_des_vars[2]', low=-10, high=10)
sysopt.add_objective(
'ssa.F[0] + ssa.dF[0][0]*(global_des_vars[0]-d0.z0)'
'+ ssa.dF[0][1]*(global_des_vars[1]-d0.z1)'
'+ ssa.dF[0][2]*(global_des_vars[2]-d0.z2)')
sysopt.add_constraint(
'ssa.G[0] + ssa.dG[0][0]*(global_des_vars[0]-d0.z0)'
'+ ssa.dG[0][1]*(global_des_vars[1]-d0.z1)'
'+ ssa.dG[0][2]*(global_des_vars[2]-d0.z2) <= 0')
sysopt.add_constraint(
'ssa.G[1] + ssa.dG[1][0]*(global_des_vars[0]-d0.z0)'
'+ ssa.dG[1][1]*(global_des_vars[1]-d0.z1)'
'+ ssa.dG[1][2]*(global_des_vars[2]-d0.z2) <= 0')
sysopt.add_constraint(
'ssa.G[2] + ssa.dG[2][0]*(global_des_vars[0]-d0.z0)'
'+ ssa.dG[2][1]*(global_des_vars[1]-d0.z1)'
'+ ssa.dG[2][2]*(global_des_vars[2]-d0.z2) <= 0')
sysopt.add_constraint(
'(global_des_vars[0]-d0.z0) >= (percent*d0.z0 +.0001)*factor**(mda.exec_count-offset)'
)
sysopt.add_constraint(
'(global_des_vars[0]-d0.z0) <= (-percent*d0.z0 -.0001)*factor**(mda.exec_count-offset)'
)
sysopt.add_constraint(
'(global_des_vars[1]-d0.z1) >= (percent*d0.z1 +.0001)*factor**(mda.exec_count-offset)'
)
sysopt.add_constraint(
'(global_des_vars[1]-d0.z1) <= (-percent*d0.z1 -.0001)*factor**(mda.exec_count-offset)'
)
sysopt.add_constraint(
'(global_des_vars[2]-d0.z2) >= (percent*d0.z2 +.0001)*factor**(mda.exec_count-offset)'
)
sysopt.add_constraint(
'(global_des_vars[2]-d0.z2) <= (-percent*d0.z2 -.0001)*factor**(mda.exec_count-offset)'
)
debug = self.add('debug', DebugComp())
debug.force_execute = True
driver = self.add('driver', FixedPointIterator())
driver.add_parameter('d0.x0', low=-1e99, high=1e99)
driver.add_parameter('d0.x1', low=-1e99, high=1e99)
driver.add_parameter('d0.x2', low=-1e99, high=1e99)
driver.add_constraint('d0_local_des_vars[0]=d0.x0')
driver.add_constraint('d0_local_des_vars[1]=d0.x1')
driver.add_constraint('d0_local_des_vars[2]=d0.x2')
driver.add_parameter('d1.x0', low=-1e99, high=1e99)
driver.add_parameter('d1.x1', low=-1e99, high=1e99)
driver.add_parameter('d1.x2', low=-1e99, high=1e99)
driver.add_constraint('d1_local_des_vars[0]=d1.x0')
driver.add_constraint('d1_local_des_vars[1]=d1.x1')
driver.add_constraint('d1_local_des_vars[2]=d1.x2')
driver.add_parameter('d2.x0', low=-1e99, high=1e99)
driver.add_parameter('d2.x1', low=-1e99, high=1e99)
driver.add_parameter('d2.x2', low=-1e99, high=1e99)
driver.add_constraint('d2_local_des_vars[0]=d2.x0')
driver.add_constraint('d2_local_des_vars[1]=d2.x1')
driver.add_constraint('d2_local_des_vars[2]=d2.x2')
driver.add_parameter(['d0.z0', 'd1.z0', 'd2.z0'], low=-1e99, high=1e99)
driver.add_parameter(['d0.z1', 'd1.z1', 'd2.z1'], low=-1e99, high=1e99)
driver.add_parameter(['d0.z2', 'd1.z2', 'd2.z2'], low=-1e99, high=1e99)
driver.add_constraint('global_des_vars[0]=d0.z0')
driver.add_constraint('global_des_vars[1]=d0.z1')
driver.add_constraint('global_des_vars[2]=d0.z2')
self.driver.workflow.add([
'mda', 'sa0', 'sa1', 'sa2', 'ssa', 'bbopt0', 'bbopt1', 'bbopt2',
'sysopt', 'debug'
])
def configure(self):
global_dvs = self.parent.get_global_des_vars()
local_dvs = self.parent.get_local_des_vars_by_comp()
objective = self.parent.get_objectives().items()[0]
constraints = self.parent.list_constraints()
coupling = self.parent.get_coupling_vars()
self.parent.add('driver', FixedPointIterator())
self.parent.driver.max_iteration = 50
self.parent.driver.tolerance = .001
initial_conditions = [
self.parent.get(param.target) for comp, param in global_dvs
]
self.parent.add_trait('global_des_vars', Array(initial_conditions))
for i, (comps, param) in enumerate(global_dvs):
targets = param.targets
self.parent.driver.add_parameter(targets,
low=param.low,
high=param.high)
self.parent.driver.add_constraint("global_des_vars[%d]=%s" %
(i, targets[0]))
for comp, local_params in local_dvs.iteritems():
initial_conditions = [
self.parent.get(param.targets[0]) for param in local_params
]
self.parent.add_trait('%s_local_des_vars' % comp,
Array(initial_conditions))
for i, param in enumerate(local_params):
self.parent.driver.add_parameter(param.targets,
low=param.low,
high=param.high)
self.parent.driver.add_constraint('%s_local_des_vars[%d]=%s' %
(comp, i, param.targets[0]))
# Multidisciplinary Analysis
mda = self.parent.add('mda', BroydenSolver())
self.parent.force_execute = True
for key, couple in coupling.iteritems():
mda.add_parameter(couple.indep.target, low=-9.e99, high=9.e99)
mda.add_constraint("%s=%s" %
(couple.indep.target, couple.dep.target))
#Global Sensitivity Analysis
ssa = self.parent.add("ssa", SensitivityDriver())
ssa.workflow.add("mda")
ssa.differentiator = FiniteDifference()
ssa.default_stepsize = 1.0e-6
ssa.force_execute = True
ssa.add_objective(objective[1].text, name=objective[0])
for comps, param in global_dvs:
ssa.add_parameter(param.targets, low=param.low, high=param.high)
for constraint in constraints:
ssa.add_constraint(constraint)
#discipline sensitivity analyses
sa_s = []
for comp, local_params in local_dvs.iteritems():
sa = self.parent.add('sa_%s' % comp, SensitivityDriver())
sa.default_stepsize = 1.0e-6
sa.force_execute = True
sa_s.append('sa_%s' % comp)
for param in local_params:
sa.add_parameter(param.targets,
low=param.low,
high=param.high,
fd_step=.001)
for constraint in constraints:
sa.add_constraint(constraint)
sa.add_objective(objective[1].text, name=objective[0])
sa.differentiator = FiniteDifference()
#Linear System Optimizations
# Discipline Optimization
# (Only discipline1 has an optimization input)
delta_x = []
df = []
dg = []
bbopts = []
for comp, local_params in local_dvs.iteritems():
bbopt = self.parent.add('bbopt_%s' % comp, CONMINdriver())
bbopt.linobj = True
bbopt.iprint = 0
bbopt.force_execute = True
bbopts.append('bbopt_%s' % comp)
x_store = "%s_local_des_vars" % comp
for i, param in enumerate(local_params):
x_store_i = "%s[%d]" % (x_store, i)
bbopt.add_parameter(x_store_i, low=param.low, high=param.high)
dx = "(%s-%s)" % (x_store_i, param.targets[0])
delta_x.append(dx)
move_limit = (param.high - param.low) * 20.0 / 100.0
bbopt.add_constraint("%s < %f" % (dx, move_limit))
bbopt.add_constraint("%s > -%f" % (dx, move_limit))
df.append("sa_%s.dF[0][%d]*%s" % (comp, i, dx))
#build the linear constraint string for each constraint
for j, const in enumerate(constraints):
dg_j = [
"sa_%s.dG[%d][%d]*%s" % (comp, j, i, x)
for i, x in enumerate(delta_x)
]
constraint_parts = ["sa_%s.G[%d]" % (comp, j)]
constraint_parts.extend(dg_j)
lin_constraint = "%s < 0" % "+".join(constraint_parts)
bbopt.add_constraint(lin_constraint)
#build the linear objective string
objective_parts = ["sa_%s.F[0]" % comp]
objective_parts.extend(df)
lin_objective = "+".join(objective_parts)
bbopt.add_objective(lin_objective)
# Global Optimization
delta_z = []
df = []
dg = []
sysopt = self.parent.add('sysopt', CONMINdriver())
sysopt.linobj = True
sysopt.iprint = 0
sysopt.force_execute = True
for i, (comps, param) in enumerate(global_dvs):
z_store = "global_des_vars[%d]" % i
target = list(param.targets)[0]
sysopt.add_parameter(z_store, low=param.low, high=param.high)
dz = "(%s-%s)" % (z_store, target)
delta_z.append(dz)
move_limit = (param.high - param.low) * 20.00 / 100.0
sysopt.add_constraint("%s < %f" % (dz, move_limit))
sysopt.add_constraint("%s > -%f" % (dz, move_limit))
df.append("ssa.dF[0][%d]*%s" % (i, dz))
dg_j = [
"ssa.dG[%d][%d]*%s" % (j, i, dz)
for j, const in enumerate(constraints)
]
dg.append(dg_j)
objective_parts = ["ssa.F[0]"]
objective_parts.extend(df)
lin_objective = "+".join(objective_parts)
sysopt.add_objective(lin_objective)
#build the linear constraint string for each constraint
for j, const in enumerate(constraints):
dg_j = [
"ssa.dG[%d][%d]*%s" % (j, i, x) for i, x in enumerate(delta_z)
]
constraint_parts = ["ssa.G[%d]" % j]
constraint_parts.extend(dg_j)
lin_constraint = "%s < 0" % "+".join(constraint_parts)
sysopt.add_constraint(lin_constraint)
self.parent.driver.workflow = SequentialWorkflow()
self.parent.driver.workflow.add("ssa")
self.parent.driver.workflow.add(sa_s)
self.parent.driver.workflow.add(bbopts)
self.parent.driver.workflow.add("sysopt")
