def configure(self):
super(SweepOpt, self).configure()
opt = self.add('opt', SLSQPdriver())
opt.add_parameter('wing_weight.cbar', low=.3, high=5)
opt.add_parameter('wing_weight.b', low=5, high=100)
opt.add_parameter('wing_weight.fos', low=2.3, high=4)
opt.add_parameter('wing_weight.y_pod', low=0,
high=15) #spanwise location of the outboard pods
opt.add_objective('level.drag')
opt.add_constraint('level.Cl < 1.1')
opt.add_constraint('wing_weight.tip_slope - .1 < 0')
#IDF
#state variables
opt.add_parameter('level.alpha', low=0, high=5, start=3)
opt.add_parameter('turning.alpha', low=0, high=10, start=3)
#compatibility constraints
opt.add_constraint(
'(level.lift/9.81 - (wing_weight.M_tot + fuse_weight.M_tot))/2500 = 0 '
)
opt.add_constraint(
'(turning.lift/9.81 - (turning.load_factor * (wing_weight.M_tot + fuse_weight.M_tot)))/1200 = 0'
)
sweep = self.add('driver', CaseIteratorDriver())
sweep.workflow.add('opt')
sweep.add_parameter('fuse_weight.N_pilot')
def configure(self):
""" Creates a new Assembly containing a Paraboloid and an optimizer"""
# pylint: disable-msg=E1101
# Create Optimizer instance
self.add('driver', SLSQPdriver())
# Create Paraboloid component instances
self.add('paraboloid', Paraboloid_shift())
# Driver process definition
self.driver.workflow.add('paraboloid')
# SQLSQP Flags
self.driver.iprint = 0
# Objective
self.driver.add_objective('paraboloid.f_xy')
# Design Variables
self.driver.add_parameter('paraboloid.x',
low=-1000000.,
high=1000000.,
scaler=0.001)
self.driver.add_parameter('paraboloid.y',
low=-1000000.,
high=1000000.,
scaler=1000.0,
adder=-1000.0)
def configure(self):
self.add('driver', SLSQPdriver())
self.add("array_comp_1", ArrayComponent())
self.add("array_comp_2", ArrayComponent())
self.driver.workflow.add(['array_comp_1', 'array_comp_2'])
self.driver.iprint = 0
self.driver.add_objective('array_comp_1.f_inArray')
self.driver.add_parameter('array_comp_1.inArray[0][0]',
low=-50.,
high=50.)
self.driver.add_parameter('array_comp_1.inArray[0][1]',
low=-50.,
high=50.)
self.driver.add_parameter('array_comp_1.inArray[1][0]',
low=-50.,
high=50.)
self.driver.add_parameter('array_comp_1.inArray[1][1]',
low=-50.,
high=50.)
self.connect("array_comp_1.f_inArray", "array_comp_2.inArray[0][0]")
self.connect("array_comp_1.f_inArray", "array_comp_2.inArray[0][2]")
self.connect("array_comp_1.f_inArray", "array_comp_2.inArray[1][0]")
self.connect("array_comp_1.f_inArray", "array_comp_2.inArray[1][2]")
def __init__(self, Ns):
super(HeliOpt, self).__init__()
# add an optimizer and an AeroStructural assembly
self.add('driver', SLSQPdriver())
self.add('aso', AeroStructuralOpt(Ns))
# Set force_fd to True. This will force the derivative system to treat
# the whole model as a single entity to finite difference it and force
# the system decomposition to put all of it into an opaque system.
#
# Full-model FD is preferable because:
# 1. There are no derivatives defined for any comps
# 2. There are a lot of interior connections that would likely make
# it much slower if you allow openmdao to finite difference the
# subassemblies like it normally does.
self.driver.gradient_options.force_fd = True
# objective: minimize total power
self.driver.add_objective('aso.Ptot')
# parameter: rotor speed
self.driver.add_parameter('aso.Omega_opt',
low=0.15 * 2 * pi,
high=0.25 * 2 * pi)
self.aso.Omega_opt = 0.2 * 2 * pi # initial value
# constraint: lift >= weight
self.driver.add_constraint('aso.Mtot*9.8-aso.Ttot<=0')
def configure(self):
# Create Optimizer instance
self.add('driver', SLSQPdriver())
# Create Paraboloid component instances
self.add('paraboloid', ParaboloidScaledShift())
# Iteration Hierarchy
self.driver.workflow.add('paraboloid')
# SLSQP Flags
self.driver.iprint = 1
# Objective
self.driver.add_objective('paraboloid.f_xy')
# Design Variables
# self.driver.add_parameter('paraboloid.x', low=-1000., high=1000.)
# self.driver.add_parameter('paraboloid.y', low=-10000, high=1000.)
# self.driver.add_parameter('paraboloid.x', low=-1000., high=1000., scaler=0.001)
# self.driver.add_parameter('paraboloid.y', low=-1000., high=1000., scaler=1000.0)
self.driver.add_parameter('paraboloid.x',
low=-1000000.,
high=1000000.,
scaler=0.001)
self.driver.add_parameter('paraboloid.y',
low=-1000000.,
high=1000000.,
scaler=1000.0,
adder=-1000.0)
def configure(self):
comp = self.add('comp', Comp())
doe = self.add('doe', NeighborhoodDOEdriver())
doe.DOEgenerator = FullFactorial()
doe.alpha = .1
doe.add_parameter('comp.x')
doe.add_response('comp.y')
doe.workflow.add('comp')
meta = self.add('meta', MetaModel(params=('x',), responses=('y', )))
meta.default_surrogate = ResponseSurface()
self.connect('doe.case_inputs.comp.x', 'meta.params.x')
self.connect('doe.case_outputs.comp.y', 'meta.responses.y')
opt = self.add('opt', SLSQPdriver())
opt.add_parameter('meta.x', high=10., low=-10.)
opt.add_objective('meta.y')
opt.workflow.add('meta')
drv = self.add('driver', FixedPointIterator())
drv.max_iteration = 2
drv.add_parameter('y')
drv.add_constraint('y=meta.y')
drv.workflow.add(['doe', 'opt'])
def configure(self):
# add an optimizer and an AeroStructural assembly
if pyopt_driver and 'SNOPT' in pyopt_driver._check_imports():
self.add("driver", pyopt_driver.pyOptDriver())
self.driver.optimizer = "SNOPT"
self.driver.options = {
# any changes to default SNOPT options?
}
else:
print 'SNOPT not available, using SLSQP'
self.add('driver', SLSQPdriver())
self.add('aso', AeroStructuralOpt())
# objective: minimize total power
self.driver.add_objective('aso.Ptot')
# parameter: rotor speed
self.driver.add_parameter('aso.Omega_opt',
low=0.15 * 2 * pi,
high=0.25 * 2 * pi)
self.aso.Omega_opt = 0.2 * 2 * pi # initial value
# constraint: lift >= weight
self.driver.add_constraint('aso.Mtot*9.8-aso.Ttot<=0')
def configure(self):
"""config"""
self.add('driver', SLSQPdriver())
self.add('testdrv', SLSQPdriver())
self.driver.workflow.add(['testdrv'])
self.add('con', TestCon())
self.testdrv.workflow.add(['con'])
self.driver.add_parameter('x', low=-10, high=10)
self.driver.add_constraint('(con.x1-x)**2 < 1e-3')
self.driver.add_objective('x**2')
self.testdrv.add_parameter('con.x1', low=-10, high=10)
self.testdrv.add_objective('(con.x1-x)**2')
self.testdrv.add_constraint('con.g1>=0')
def test_nested(self):
asm3 = Assembly()
asm3.add('comp1', ExecComp(exprs=['z=x+y']))
driver = asm3.add('driver', SLSQPdriver())
driver.workflow.add('comp1')
driver.add_parameter('comp1.y', low=-1, high=1, start=0)
driver.add_objective('comp1.z')
driver.add_constraint('comp1.z >= 0')
asm3.create_passthrough('comp1.x')
asm3.create_passthrough('comp1.z')
asm2 = Assembly()
asm2.add('comp1', ExecComp(exprs=['z=x+y']))
asm2.add('asm3', asm3)
asm2.connect('comp1.z', 'asm3.x')
driver = asm2.add('driver', SLSQPdriver())
driver.workflow.add(('comp1', 'asm3'))
driver.add_parameter('comp1.y', low=-1, high=1, start=0)
driver.add_objective('asm3.z')
driver.add_constraint('comp1.z >= 0')
asm2.create_passthrough('comp1.x')
asm2.create_passthrough('asm3.z')
asm1 = set_as_top(Assembly())
asm1.add('comp1', ExecComp(exprs=['z=x+y']))
asm1.add('asm2', asm2)
asm1.connect('comp1.z', 'asm2.x')
driver = asm1.add('driver', SLSQPdriver())
driver.workflow.add(('comp1', 'asm2'))
driver.add_parameter('comp1.y', low=-1, high=1, start=0)
driver.add_objective('asm2.z')
driver.add_constraint('comp1.z >= 0')
sout = StringIO()
asm1.recorders = [JSONCaseRecorder(sout)]
asm1.run()
if os.environ.get('REGEN_JSON_FILES'):
with open('nested.new', 'w') as out:
out.write(sout.getvalue())
verify_json(self, sout, 'nested.json')
def configure(self):
#self.add('driver', COBYLAdriver())
#self.add('driver', CONMINdriver())
#self.add('driver', NEWSUMTdriver())
self.add('driver', SLSQPdriver())
self.add('topopt', TopOpt())
self.driver.workflow.add('topopt')
self.driver.iprint = 0 # optimizers verbosity
self.driver.add_constraint('topopt.vol <= 0.5')
self.driver.add_objective('topopt.c')
self.driver.add_parameter('topopt.var', low=0.0, high=1.0)
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 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
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 configure(self):
""" Creates a 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('dummy', Dummy())
self.dummy.force_execute = True
self.add('solver', FixedPointIterator())
self.driver.workflow.add(['dummy', 'solver'])
# Inner Loop - Full Multidisciplinary Solve via fixed point iteration
self.add('dis1', sellar.Discipline1_WithDerivatives())
self.add('dis2', sellar.Discipline2_WithDerivatives())
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=-1.e99, high=1.e99)
self.solver.add_constraint('dis2.y2 = dis1.y2')
# Solver settings
self.solver.max_iteration = 100
self.solver.tolerance = .00001
self.solver.print_convergence = False
# 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 configure(self):
self.add("comp1", simpleComp())
self.add("comp2", simpleComp())
self.add('driver', SLSQPdriver())
self.driver.workflow.add(["comp1", "comp2"])
self.connect("comp1.z", "comp2.x")
self.connect("comp1.x", "comp2.A[0]")
self.connect("comp1.z", "comp2.A[1]")
self.driver.add_parameter('comp1.A', low=-20, high=20)
self.driver.add_parameter('comp1.x', low=0, high=10)
self.driver.add_parameter('comp1.y', low=0, high=10)
self.driver.add_objective('comp2.z')
def test_SLSQP(self):
top = set_as_top(Assembly())
top.add('parab1', Parab1())
top.add('parab2', Parab2())
top.add('driver', SLSQPdriver())
top.driver.workflow.add(['parab1', 'parab2'])
top.driver.add_parameter(['parab1.x', 'parab2.x'], low=-100, high=100)
top.driver.add_parameter(['parab1.y', 'parab2.y'], low=-100, high=100)
top.driver.add_objective('parab1.f_xy + parab2.f_xy')
top.driver.add_constraint('parab1.x-parab1.y >= 15.0')
top.run()
assert_rel_error(self, top.parab1.x, 7.166, 0.001)
assert_rel_error(self, top.parab1.y, -7.833, 0.001)
assert_rel_error(self, top._pseudo_0.out0, -27.083, 0.001)
def configure(self):
# Create Optimizer instance
self.add('driver', SLSQPdriver())
# Create Paraboloid component instances
self.add('paraboloid', Paraboloid())
# Iteration Hierarchy
self.driver.workflow.add('paraboloid')
# SLSQP Flags
self.driver.iprint = 3
# Objective
self.driver.add_objective('paraboloid.f_xy')
# Design Variables
self.driver.add_parameter('paraboloid.x', low=-50., high=50.)
self.driver.add_parameter('paraboloid.y', low=-50., high=50.)
def configure(self):
"""Setup an IDF architecture inside this assembly.
"""
#create the top level optimizer
self.parent.add("driver", SLSQPdriver())
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)
self.parent.driver.add_parameter(
v, name=k) # and add the broadcast parameters to the driver
v.initialize(self.parent)
for k, v in self.parent.get_local_des_vars():
local_dvs.append(v)
#add the local design variables to the driver
self.parent.driver.add_parameter(v, name=k)
v.initialize(self.parent)
#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 objective
objective = self.parent.get_objectives().items()[0]
self.parent.driver.add_objective(objective[1].text, name=objective[0])
#add the coupling vars parameters/constraints to the solver
for key, couple in self.parent.list_coupling_vars().iteritems():
self.parent.driver.add_parameter(couple.indep.target,
low=-9.e99,
high=9.e99,
name=key)
self.parent.driver.add_constraint(
"(%s-%s) <= .001" % (couple.indep.target, couple.dep.target))
self.parent.driver.add_constraint(
"(%s-%s) <= .001" % (couple.dep.target, couple.indep.target))
def configure(self):
self.add('driver', SLSQPdriver())
self.driver.gradient_options.force_fd = True
self.driver.iout = 1
self.driver.iprint = 3
self.driver.maxiter = 100
self.add('builder', Builder())
self.driver.workflow.add('builder')
self.add('cid', CIDAssembly())
self.driver.workflow.add('cid')
self.connect('builder.x', 'cid.x_in')
self.connect('builder.y', 'cid.y_in')
self.driver.add_parameter('builder.x0', low=-50, high=50)
self.driver.add_parameter('builder.y0', low=-50, high=50)
self.driver.add_constraint('builder.x0-builder.y0 >= 15.0')
self.driver.add_objective('cid.f_xy')
def configure(self):
myConfig = Config()
self.add('deform', Deform())
self.add('solve', Solve())
myConfig.read('inv_NACA0012.cfg')
self.deform.config_in = myConfig
self.connect('deform.mesh_file', 'solve.mesh_file')
self.connect('deform.config_out', 'solve.config_in')
self.add('driver', SLSQPdriver())
self.driver.workflow.add(['deform', 'solve'])
for j in range(38):
self.driver.add_parameter('deform.dv_vals[%d]' % j, low=-.05, high=.05)
self.driver.add_objective('solve.DRAG*0.001')
self.driver.add_constraint('solve.LIFT * 0.001 > .328188 * 0.001')
def configure(self):
self.add('driver', SLSQPdriver())
self.add("paraboloid_1", ArrayParaboloid())
self.add("paraboloid_2", ArrayParaboloid())
self.driver.workflow.add(['paraboloid_1', 'paraboloid_2'])
self.driver.iprint = 0
self.driver.add_objective('paraboloid_1.f_xy')
self.driver.add_parameter('paraboloid_1.inArray[0]',
low=-50.,
high=50.)
self.driver.add_parameter('paraboloid_1.inArray[1]',
low=-50.,
high=50.)
self.connect("paraboloid_1.f_xy", "paraboloid_2.inArray[0]")
self.connect("paraboloid_1.f_xy", "paraboloid_2.inArray[1]")
def configure(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# create Optimizer instance
self.add('driver', SLSQPdriver())
# Disciplines
self.add('dis1', sellar.Discipline1_WithDerivatives())
self.add('dis2', sellar.Discipline2_WithDerivatives())
# Driver process definition
self.driver.workflow.add(['dis1', 'dis2'])
#self.driver.workflow.add(['dis1'])
# Optimization parameters
self.driver.add_objective(
'(dis1.x1)**2 + dis1.z2 + dis1.y1 + math.exp(-dis2.y2)')
#Global Design Variables
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)
#Local Design Variables and Coupling Variables
self.driver.add_parameter('dis1.x1', low=0.0, high=10.0)
self.driver.add_parameter('dis2.y1', low=-1e99, high=1e99)
self.driver.add_parameter('dis1.y2', low=-1e99, high=1e99)
self.driver.add_constraint('3.16 < dis1.y1')
self.driver.add_constraint('dis2.y2 < 24.0')
self.driver.add_constraint('(dis2.y1-dis1.y1)**2 <= 0')
self.driver.add_constraint('(dis2.y2-dis1.y2)**2 <= 0')
self.driver.iprint = 0
def configure(self):
""" Creates counter new Assembly containing counter Paraboloid and an optimizer"""
# Create Paraboloid component instances
self.add('paraboloid', Paraboloid())
# Create Optimizer instance
self.add('driver', SLSQPdriver())
# Driver process definition
self.driver.workflow.add('paraboloid')
# Optimzier Flags
self.driver.iprint = 0
# Objective
self.driver.add_objective('paraboloid.f_xy')
# Design Variables
self.driver.add_parameter('paraboloid.x', low=-50., high=50.)
self.driver.add_parameter('paraboloid.y', low=-50., high=50.)
# Constraints
self.driver.add_constraint('paraboloid.x-paraboloid.y >= 15.0')
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):
global_dvs = self.parent.get_global_des_vars()
local_dvs = self.parent.get_local_des_vars()
all_dvs_by_comp = self.parent.get_des_vars_by_comp()
objective = self.parent.get_objectives()
constraints = self.parent.list_constraints()
constraints_by_comp = self.parent.get_constraints_by_comp()
coupling = self.parent.list_coupling_vars()
coupl_indeps_by_comp = self.parent.get_coupling_indeps_by_comp()
coupl_deps_by_comp = self.parent.get_coupling_deps_by_comp()
self.target_var_map = dict()
#Global Driver
global_opt = self.parent.add('driver', SLSQPdriver())
global_opt.recorders = self.data_recorders
#set initial values
for comp, param in global_dvs:
param.initialize(self.parent, self.parent)
for comp, param in local_dvs:
param.initialize(self.parent, self.parent)
for key, couple in coupling.iteritems():
couple.indep.set(couple.start)
initial_conditions = np.array(
[param.evaluate() for comp, param in global_dvs]).flatten()
self.parent.add_trait('global_des_var_targets',
Array(initial_conditions, iotype="in"))
for i, (comp, param) in enumerate(global_dvs):
target_var = 'global_des_var_targets[%d]' % i
global_opt.add_parameter(target_var,
low=param.low,
high=param.high)
#associate all targets with this target variable for global optimizer
for var in param.targets:
self.target_var_map[var] = target_var
initial_conditions = [
couple.indep.evaluate() for key, couple in coupling.iteritems()
]
#print "coupling initial conditions: ", initial_conditions
self.parent.add_trait('coupling_var_targets',
Array(initial_conditions, iotype="in"))
for i, (key, couple) in enumerate(coupling.iteritems()):
target_var = 'coupling_var_targets[%d]' % i
low = couple.indep.low or -1e99
high = couple.indep.high or 1e99
global_opt.add_parameter(target_var, low=low, high=high)
self.target_var_map[couple.indep.target] = target_var
self.target_var_map[couple.dep.target] = target_var
initial_conditions = [param.evaluate()[0] for comp, param in local_dvs]
#print "local initial conditions: ", initial_conditions, initial_conditions.shape; exit()
self.parent.add_trait("local_des_var_targets",
Array(initial_conditions, iotype="in"))
for i, (comp, param) in enumerate(local_dvs):
#Target variables for the local optimizations
target_var = 'local_des_var_targets[%d]' % i
self.target_var_map[param.target] = target_var
global_opt.add_parameter(target_var,
low=param.low,
high=param.high)
#print "param: ",target_var,param.low,param.high
#create the new objective with the target variables
obj = objective.items()[0]
new_objective = str(obj[1].text)
for old_var, new_var in sorted(self.target_var_map.items(),
key=lambda x: len(x[0]),
reverse=True):
new_objective = new_objective.replace(old_var, new_var)
global_opt.add_objective(new_objective)
#setup the local optimizations
for comp, params in all_dvs_by_comp.iteritems():
local_opt = self.parent.add('local_opt_%s' % comp, SLSQPdriver())
local_opt.iprint = 0
global_opt.workflow.add(local_opt.name)
residuals = []
for param in params:
local_opt.add_parameter(param.target,
low=param.low,
high=param.high)
residuals.append(
"(%s-%s)**2" %
(self.target_var_map[param.target], param.target))
if comp in coupl_indeps_by_comp:
for couple in coupl_indeps_by_comp[comp]:
if couple.indep.low is not None:
low = couple.indep.low
else:
low = -1e99
if couple.indep.high is not None:
high = couple.indep.high
else:
high = 1e99
#print couple, couple.indep.get_metadata()
#exit()
local_opt.add_parameter(couple.indep.target,
low=low,
high=high)
residuals.append("(%s-%s)**2" %
(self.target_var_map[couple.indep.target],
couple.indep.target))
if comp in coupl_deps_by_comp:
for couple in coupl_deps_by_comp[comp]:
residuals.append("(%s-%s)**2" %
(self.target_var_map[couple.dep.target],
couple.dep.target))
if comp in constraints_by_comp:
for const in constraints_by_comp[comp]:
local_opt.add_constraint(str(const))
residuals = "+".join(residuals)
global_constraint = "%s<=0" % residuals
global_opt.add_constraint(global_constraint)
local_opt.add_objective(residuals)
def configure(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
#objective = '(dis1.x1)**2 + dis1.z2 + dis1.y1 + exp(-dis2.y2)'
#constraint1 = 'dis1.y1 > 3.16'
#constraint2 = 'dis2.y2 < 24.0'
# Metamodel for sellar discipline 1
self.add("meta_model_dis1", MetaModel())
self.meta_model_dis1.surrogates = {"y1": ResponseSurface()}
self.meta_model_dis1.model = SellarDiscipline1()
self.meta_model_dis1.recorder = DBCaseRecorder()
self.meta_model_dis1.force_execute = True
# Metamodel for sellar discipline 2
self.add("meta_model_dis2", MetaModel())
self.meta_model_dis2.surrogates = {"y2": ResponseSurface()}
self.meta_model_dis2.model = SellarDiscipline2()
self.meta_model_dis2.recorder = DBCaseRecorder()
self.meta_model_dis2.force_execute = True
#training metalmodel for disc1
# self.add("DOE_Trainer_dis2",NeighborhoodDOEdriver())
# self.DOE_Trainer_dis2.DOEgenerator = CentralComposite()
# self.DOE_Trainer_dis2.alpha = .1
# self.DOE_Trainer_dis2.add_parameter("meta_model_dis2.z1",low=-10,high=10,start=5.0)
# self.DOE_Trainer_dis2.add_parameter("meta_model_dis2.z2",low=0,high=10,start=2.0)
# self.DOE_Trainer_dis2.add_parameter("meta_model_dis2.y1",low=0,high=20)
# self.DOE_Trainer_dis2.add_event("meta_model_dis2.train_next")
# self.DOE_Trainer_dis2.force_execute = True
#optimization of global objective function
self.add('sysopt', SLSQPdriver())
self.sysopt.add_objective(
'(meta_model_dis1.x1)**2 + meta_model_dis1.z2 + meta_model_dis1.y1 + math.exp(-meta_model_dis2.y2)'
)
self.sysopt.add_parameter(['meta_model_dis1.z1', 'meta_model_dis2.z1'],
low=-10,
high=10.0,
start=5.0)
self.sysopt.add_parameter(['meta_model_dis1.z2', 'meta_model_dis2.z2'],
low=0,
high=10.0,
start=2.0)
self.sysopt.add_parameter('meta_model_dis1.y2', low=-1e99, high=1e99)
self.sysopt.add_parameter('meta_model_dis2.y1', low=-1e99, high=1e99)
#feasibility constraints
self.sysopt.add_constraint('meta_model_dis1.y2 <= meta_model_dis2.y2')
self.sysopt.add_constraint('meta_model_dis1.y2 >= meta_model_dis2.y2')
self.sysopt.add_constraint('meta_model_dis2.y1 <= meta_model_dis1.y1')
self.sysopt.add_constraint('meta_model_dis2.y1 >= meta_model_dis1.y1')
self.sysopt.add_constraint('3.16 < meta_model_dis1.y1')
self.sysopt.add_constraint('meta_model_dis2.y2 < 24.0')
self.sysopt.force_execute = True
#optimization of discipline 1 (discipline 2 of the sellar problem has no local variables)
self.add('local_opt_dis1', SLSQPdriver())
self.local_opt_dis1.add_objective('meta_model_dis1.y1')
self.local_opt_dis1.add_parameter('meta_model_dis1.x1',
low=0,
high=10.0)
self.local_opt_dis1.add_constraint('3.16 < meta_model_dis1.y1')
self.local_opt_dis1.add_event('meta_model_dis1.train_next')
self.local_opt_dis1.force_execute = True
self.local_opt_dis1.workflow.add(['meta_model_dis1'])
#training metalmodel for disc1
self.add("DOE_Trainer_dis1", NeighborhoodDOEdriver())
self.DOE_Trainer_dis1.DOEgenerator = CentralComposite()
self.DOE_Trainer_dis1.alpha = .1
self.DOE_Trainer_dis1.add_parameter("meta_model_dis1.z1",
low=-10,
high=10,
start=5.0)
self.DOE_Trainer_dis1.add_parameter("meta_model_dis1.z2",
low=0,
high=10,
start=2.0)
self.DOE_Trainer_dis1.add_parameter("meta_model_dis1.y2",
low=-100,
high=100)
self.DOE_Trainer_dis1.add_event("meta_model_dis1.train_next")
self.DOE_Trainer_dis1.force_execute = True
self.DOE_Trainer_dis1.workflow.add("local_opt_dis1")
self.add('reset_train', Driver())
self.reset_train.add_event('meta_model_dis1.reset_training_data')
self.reset_train.add_event('meta_model_dis2.reset_training_data')
self.reset_train.workflow.add(['meta_model_dis1', 'meta_model_dis2'])
self.reset_train.force_execute = True
#build workflow for bliss2000
self.add('driver', FixedPointIterator())
#self.add('main_driver', IterateUntil())
#self.main_driver.max_iterations = 1
self.driver.tolerance = .0001
# self.driver.workflow.add(['local_opt_dis1','reset_train','DOE_Trainer_dis1','DOE_Trainer_dis2','sysopt'])
self.driver.workflow.add(['sysopt'])
self.driver.add_parameter('x1_store', low=0, high=10.0)
self.driver.add_constraint('meta_model_dis1.x1 = x1_store')
self.driver.add_parameter('z1_store', low=0, high=10.0)
self.driver.add_constraint('meta_model_dis1.z1 = z1_store')
self.driver.add_parameter('z2_store', low=0, high=10.0)
self.driver.add_constraint('meta_model_dis1.z2 = z2_store')
def configure(self):
self.add('driver', SLSQPdriver())
self.add('')
#self.driver.add_parameter(
#"Orbit_Initial.RAAN", low=-180, high=180)
#self.driver.add_parameter(
#"Orbit_Initial.Inc", low=0, high=90)
#self.driver.add_parameter(
#"Orbit_Initial.argPerigee", low=0, high=90)
if __name__ == "__main__":
import time
from scipy.optimize import fmin, fmin_slsqp
print 30 * "-"
print "with OpenMDAO optimizer:"
a = CADRE_Launch(10)
a.Orbit_Initial.Inc = 15
a.add('driver', SLSQPdriver())
#a.add('driver', CONMINdriver())
#a.driver.conmin_diff = True
a.driver.add_objective("-Lat_uniform.k - Lon_uniform.k")
a.driver.add_parameter(
["Orbit_Initial.altPerigee", "Orbit_Initial.altApogee"],
low=500,
high=1000)
a.driver.add_parameter("Orbit_Initial.RAAN", low=-180, high=180)
a.driver.add_parameter("Orbit_Initial.Inc", low=0, high=90)
a.driver.add_parameter("Orbit_Initial.argPerigee", low=0, high=90)
tt = time.time()
a.run()
#outputs = ['Orbit_Dynamics.r_e2b_I']
outputs = None
def configure(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# Sub assembly
sub = self.add('sub', Assembly())
# Inner Loop - Full Multidisciplinary Solve via fixed point iteration
sub.add('driver', FixedPointIterator())
sub.add('dis1', sellar.Discipline1())
sub.add('dis2', sellar.Discipline2())
sub.driver.workflow.add(['dis1', 'dis2'])
# Make all connections
sub.connect('dis1.y1', 'dis2.y1')
sub.connect('dis1.z1', 'dis2.z1')
# Iteration loop
sub.driver.add_parameter('dis1.y2')
sub.driver.add_constraint('dis2.y2 = dis1.y2')
# Solver settings
sub.driver.max_iteration = 100
sub.driver.tolerance = .00001
sub.driver.print_convergence = False
# Subassy boundaries
sub.add('globals', VarTree(Globals(), iotype='in'))
sub.add('states', VarTree(States(), iotype='out'))
sub.connect('globals.z1', 'dis1.z1')
# Note, dis1.z2 is connected by input-input conn
sub.connect('globals.z2', 'dis1.z2')
sub.connect('globals.z2', 'dis2.z2')
sub.create_passthrough('dis1.x1')
sub.connect('dis1.y1', 'states.y[0]')
sub.connect('dis2.y2', 'states.y[1]')
# Global Optimization
self.add('driver', SLSQPdriver())
self.driver.gradient_options.force_fd = True
#self.driver.iprint = 3
# Extra comp
self.add('half', Half())
self.connect('half.z2b', 'sub.globals.z2')
self.driver.workflow.add(['half', 'sub'])
# Add Parameters to optimizer
self.driver.add_parameter('sub.globals.z1', low=-10.0, high=10.0)
self.driver.add_parameter('half.z2a', low=0.0, high=10.0)
self.driver.add_parameter('sub.x1', low=0.0, high=10.0)
# Optimization parameters
self.driver.add_objective(
'(sub.x1)**2 + sub.globals.z2 + sub.states.y[0] + math.exp(-sub.states.y[1])'
)
self.driver.add_constraint('3.16 < sub.states.y[0]')
self.driver.add_constraint('sub.states.y[1] < 24.0')
self.sub.globals.z1 = 5.0
self.half.z2a = 2.0
self.sub.x1 = 1.0
def configure(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
# Global Optimization
self.add('driver', SLSQPdriver())
self.add('localopt1', SLSQPdriver())
self.add('localopt2', SLSQPdriver())
self.driver.workflow.add(['localopt1', 'localopt2'])
# Local Optimization 1
self.add('dis1', sellar.Discipline1())
self.localopt1.workflow.add('dis1')
# Local Optimization 2
self.add('dis2a', SellarDiscipline2a())
self.add('dis2b', SellarDiscipline2b())
self.add('dis2c', SellarDiscipline2c())
self.connect('dis2a.temp1', 'dis2b.temp1')
self.connect('dis2b.temp2', 'dis2c.temp2')
self.localopt2.workflow.add(['dis2a', 'dis2b', 'dis2c'])
#Parameters - Global Optimization
# using group parameters to 'broadcast' same data
self.driver.add_objective('x1**2 + z2 + y1 + math.exp(-y2)')
for param, low, high in zip(['z1', 'z2', 'x1', 'y1', 'y2'],
[-10.0, 0.0, 0.0, 3.16, -10.0],
[10.0, 10.0, 10.0, 10, 24.0]):
self.driver.add_parameter(param, low=low, high=high)
map(self.driver.add_constraint, [
'(z1-dis1.z1)**2 + (z2-dis1.z2)**2 + (x1-dis1.x1)**2 + '
'(y1-dis1.y1)**2 + (y2-dis1.y2)**2 < 0',
'(z1-dis2b.z1)**2 + (z2-dis2c.z2)**2 + (y1-dis2a.y1)**2 + '
'(y2-dis2c.y2)**2 < 0'])
self.driver.iprint = 0
self.driver.itmax = 100
self.driver.fdch = .003
self.driver.fdchm = .003
self.driver.delfun = .0001
self.driver.dabfun = .00001
self.driver.ct = -.0008
self.driver.ctlmin = 0.0008
#Parameters - Local Optimization 1
self.localopt1.add_objective('(z1-dis1.z1)**2 + '
'(z2-dis1.z2)**2 + '
'(x1-dis1.x1)**2 + '
'(y1-dis1.y1)**2 + '
'(y2-dis1.y2)**2')
for param, low, high in zip(['dis1.z1', 'dis1.z2', 'dis1.x1', 'dis1.y2'],
[-10.0, 0.0, 0.0, -10.0],
[10.0, 10.0, 10.0, 24.0]):
self.localopt1.add_parameter(param, low=low, high=high)
self.localopt1.iprint = 0
self.localopt1.itmax = 100
self.localopt1.fdch = .003
self.localopt1.fdchm = .003
self.localopt1.delfun = .0001
self.localopt1.dabfun = .000001
#Parameters - Local Optimization 2
self.localopt2.add_objective('(z1-dis2b.z1)**2 + '
'(z2-dis2c.z2)**2 + '
'(y1-dis2a.y1)**2 + '
'(y2-dis2c.y2)**2')
for param, low, high in zip(['dis2b.z1', 'dis2c.z2', 'dis2a.y1'],
[-10.0, 0.0, 3.16],
[10.0, 10.0, 10]):
self.localopt2.add_parameter(param, low=low, high=high)
self.localopt2.iprint = 0
self.localopt2.itmax = 100
self.localopt2.fdch = .003
self.localopt2.fdchm = .003
self.localopt2.delfun = .001
self.localopt2.dabfun = .00001
