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'])