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