def test_opt1_with_OpenMDAO_FD(self):
self.top.driver.add_objective('comp.result')
self.top.driver.add_parameter('comp.x[0]', 2.0, 50.0)
self.top.driver.add_parameter('comp.x[1]', -50.0, 50.0)
map(self.top.driver.add_constraint,
['-10.0 + 10.0 * comp.x[0] - comp.x[1] > 0.0'])
self.top.driver.ilin = [1]
self.top.driver.differentiator = FiniteDifference()
self.top.run()
assert_rel_error(self, self.top.comp.opt_objective,
self.top.driver.eval_objective(), 0.001)
self.assertAlmostEqual(self.top.comp.opt_design_vars[0],
self.top.comp.x[0],
places=2)
self.assertAlmostEqual(self.top.comp.opt_design_vars[1],
self.top.comp.x[1],
places=2)
def __init__(self):
""" Initialize it"""
# pylint: disable-msg=E1101
super(Assy, self).__init__()
self.add('comp', Comp())
self.add('driver', Driv())
self.driver.workflow.add(['comp'])
self.driver.differentiator = FiniteDifference()
self.driver.add_objective('comp.y')
self.driver.add_objective('comp.v')
# Design Variables
self.driver.add_parameter('comp.x', low=-50., high=50., fd_step=.01)
self.driver.add_parameter('comp.u', low=-50., high=50., fd_step=.01)
self.driver.add_constraint('comp.x + comp.y + 2.0*comp.u < 30.0',
name="Con1")
self.driver.add_constraint('comp.x + comp.y + 3.0*comp.u = 100.0',
name="ConE")
def __init__(self, *args, **kwargs):
super(SLSQPdriver, self).__init__(*args, **kwargs)
self.error_messages = {
-1 : "Gradient evaluation required (g & a)",
1 : "Function evaluation required (f & c)",
2 : "More equality constraints than independent variables",
3 : "More than 3*n iterations in LSQ subproblem",
4 : "Inequality constraints incompatible",
5 : "Singular matrix E in LSQ subproblem",
6 : "Singular matrix C in LSQ subproblem",
7 : "Rank-deficient equality constraint subproblem HFTI",
8 : "Positive directional derivative for linesearch",
9 : "Iteration limit exceeded",
}
self.x = zeros(0,'d')
self.x_lower_bounds = zeros(0,'d')
self.x_upper_bounds = zeros(0,'d')
# We auto-fill the slot because the gradient is required
# in this implementation
self.differentiator = FiniteDifference()
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()
comp_constraints = self.parent.get_constraints_by_comp()
coupling = self.parent.list_coupling_vars()
self.parent.add('driver', FixedPointIterator())
self.parent.driver.max_iteration = 15
self.parent.driver.tolerance = .005
initial_conditions = [param.start 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 = [param.start 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())
mda.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.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])
sa.differentiator = FiniteDifference()
#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.differentiator = FiniteDifference()
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)
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*%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.differentiator = FiniteDifference()
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)
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*%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 = SequentialWorkflow()
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.differentiator = FiniteDifference()
global_opt.recorders = self.data_recorders
global_opt.print_vars = ['dis1.y1', 'dis2.y2']
global_opt.iprint = 0
initial_conditions = [param.evaluate() for comp,param in global_dvs]
#print "global initial conditions: ", initial_conditions
self.parent.add_trait('global_des_var_targets',Array(initial_conditions))
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))
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() for comp,param in local_dvs]
#print "local initial conditions: ", initial_conditions
self.parent.add_trait("local_des_var_targets",Array(initial_conditions))
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 = 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,name=obj[1])
#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.differentiator = FiniteDifference()
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]:
low = couple.indep.low or -1e99
high = couple.indep.high or 1e99
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<=.001"%residuals
global_opt.add_constraint(global_constraint)
local_opt.add_objective(residuals)
""" print local_opt.name
print local_opt.get_objectives().keys()[0]
for param in local_opt.get_parameters():
print param
print "constraints: "
for constraint in local_opt.list_constraints():
print constraint
print
print
print global_opt.name
print global_opt.get_objectives().keys()[0]
for param in global_opt.get_parameters():
print param
print "constraints: "
for constraint in global_opt.list_constraints():
print constraint
print
print"""
def configure(self):
"""Setup a BLISS2000 architecture inside this assembly.
"""
global_dvs = self.parent.get_global_des_vars()
des_vars=self.parent.get_des_vars_by_comp()
local_dvs_by_comp = self.parent.get_local_des_vars_by_comp()
global_dvs_by_comp = self.parent.get_global_des_vars_by_comp()
locals=self.parent.get_local_des_vars()
objective = self.parent.get_objectives().items()[0]
comp_constraints = self.parent.get_constraints_by_comp()
coupling = self.parent.list_coupling_vars()
couple_deps = self.parent.get_coupling_deps_by_comp()
couple_indeps = self.parent.get_coupling_indeps_by_comp()
driver=self.parent.add("driver",FixedPointIterator())
driver.workflow = SequentialWorkflow()
driver.max_iteration=15 #should be enough to converge
driver.tolerance = .005
meta_models = {}
self.sub_system_opts = {}
system_var_map = {}
for comp in des_vars:
mm_name = "meta_model_%s"%comp
meta_model = self.parent.add(mm_name,MetaModel()) #metamodel now replaces old component with same name
driver.add_event("%s.reset_training_data"%mm_name)
meta_models[comp] = meta_model
meta_model.default_surrogate = ResponseSurface()
#if there are locals, you need to make a SubSystemOpt assembly
comp_obj = self.parent.get(comp)
sso = self.parent.add('sub_system_opt_%s'%comp,
SubSystemOpt(comp_obj,
global_dvs_by_comp.get(comp),
local_dvs_by_comp.get(comp),
couple_deps.get(comp),
couple_indeps.get(comp),
comp_constraints.get(comp)))
self.sub_system_opts[comp] = sso
meta_model.model = sso
for name,mapped_name in sso.var_map.iteritems():
system_var_map[name] = "%s.%s"%(mm_name,mapped_name)
meta_model.recorder = DBCaseRecorder()
#add a doe trainer for each metamodel
dis_doe=self.parent.add("DOE_Trainer_%s"%comp,NeighborhoodDOEdriver())
for couple in couple_indeps[comp] :
mapped_name = system_var_map[couple.indep.target]
dis_doe.add_parameter(mapped_name,low=-1e99,high=1e99) #change to -1e99/1e99
for dv in global_dvs_by_comp[comp]:
dis_doe.add_parameter(system_var_map[dv.target],low=dv.low, high=dv.high,start=dv.start)
if local_dvs_by_comp.get(comp): #add weights if they are there
for w in meta_model.model.weights:
dis_doe.add_parameter("meta_model_%s.%s"%(comp,w),low=-3,high=3)
num_params = len(dis_doe.get_parameters())
dis_doe.DOEgenerator = LatinHypercube((num_params**2+3*num_params+2)/2)
dis_doe.alpha= .1
dis_doe.beta = .01
dis_doe.add_event("meta_model_%s.train_next"%comp)
dis_doe.force_execute = True
driver.workflow.add(dis_doe.name) #run all doe training before system optimziation
#optimization of system objective function using the discipline meta models
sysopt=self.parent.add('sysopt', SLSQPdriver())
sysopt.recorders = self.data_recorders
sysopt.iprint = 0
sysopt.differentiator = FiniteDifference()
obj2= objective[1].text
#for comp in objective[1].get_referenced_compnames():
# obj2=obj2.replace(comp,"meta_model_%s"%comp)
for var_name, mapped_name in system_var_map.iteritems():
obj2=obj2.replace(var_name,mapped_name)
sysopt.add_objective(obj2)
#add global design variables as parameters
for param,group in global_dvs:
plist=[system_var_map[t] for t in group.targets]
sysopt.add_parameter(plist, low=group.low, high=group.high,start=group.start)
#add the subsytem weights to the system optimization
for comp,sso in self.sub_system_opts.iteritems():
mm_name = "meta_model_%s"%comp
for w in sso.weights:
sysopt.add_parameter("%s.%s"%(mm_name,w),low=-3,high=3)
for key,couple in coupling.iteritems():
s=couple.indep.target
mapped_name = system_var_map[s]
sysopt.add_parameter(mapped_name, low=-1e99, high=1e99)
#feasibility constraints, referenced to metamodels
s1,s2= system_var_map[couple.dep.target], system_var_map[couple.indep.target]
sysopt.add_constraint('(%s-%s)**2<=0.0001'%(s2,s1))
#sysopt.add_constraint('%s>=%s'%(s2,s1))
#add constraints, referenced to metamodels
for comp,constraints in comp_constraints.iteritems():
for c in constraints:
new_c = str(c)
for var,mapped_name in system_var_map.iteritems():
new_c = new_c.replace(var,mapped_name)
sysopt.add_constraint(new_c)
driver.workflow.add('sysopt')
#setup paramter for fixedpointiterator
comp=des_vars.keys()[0]
mm='meta_model_%s'%comp
#create some placeholder variables for the fixed point iteration
for l in locals:
s=system_var_map[l[0]].replace(".","_")
s2='%s_store'%s
self.parent.add(s2,Float(0.0))
driver.add_parameter(s2 , low=l[1].low, high=l[1].high)
driver.add_constraint('%s = %s'%(system_var_map[l[1].target],s2))
for i,g in enumerate(global_dvs):
s2='global%d_store'%i
self.parent.add(s2,Float(0.0))
driver.add_parameter(s2 , low=g[1].low, high=g[1].high)
driver.add_constraint('%s = %s'%(system_var_map[g[1].target],s2))
def __init__(self):
""" Creates a new Assembly with this problem
Optimal Design at (1.9776, 0, 0)
Optimal Objective = 3.18339"""
super(SellarBLISS, self).__init__()
# 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')
self.mda.force_execute = True
# Discipline 1 Sensitivity Analysis
self.add('sa_dis1', SensitivityDriver())
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')
self.sa_dis1.differentiator = FiniteDifference()
self.sa_dis1.default_stepsize = 1.0e-6
self.sa_dis1.force_execute = True
# 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')
self.ssa.differentiator = FiniteDifference()
self.ssa.default_stepsize = 1.0e-6
self.ssa.force_execute = True
# 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.linobj = True
self.bbopt1.iprint = 0
self.bbopt1.force_execute = 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.bbopt1.add_constraint('z_store[0]-dis1.z1<.5')
self.bbopt1.add_constraint('z_store[0]-dis1.z1>-.5')
self.bbopt1.add_constraint('z_store[1]-dis1.z2<.5')
self.bbopt1.add_constraint('z_store[1]-dis1.z2>-.5')
self.sysopt.linobj = True
self.sysopt.iprint = 0
self.sysopt.force_execute = True
self.driver.workflow.add(['ssa', 'sa_dis1', 'bbopt1', 'sysopt'])