def translateProgramToPyOpt(dfovecProgram): # Currently only handles inequality def objfunc(x): f = dfovecProgram.objective(x) g = [] if dfovecProgram.hasInequalityConstraints(): g = dfovecProgram.inequalityConstraints(x) fail = 0 return f, g, fail opt_prob = Optimization('Dfovec problem', objfunc) for i in range(len(dfovecProgram.x0)): opt_prob.addVar('x' + str(i), lower=-1000.0, upper=1000.0, value=dfovecProgram.x0[i]) opt_prob.addObj('f') numIneq = dfovecProgram.getNumInequalityConstraints() opt_prob.addConGroup('g', numIneq, type='i', lower=[-10000] * numIneq, upper=[0] * numIneq) print(opt_prob) return opt_prob
def traj_optim_static(paths, tree): path, envs, modes, mnps = paths guard_index = [0] n = len(modes) v_init = np.zeros((n, 3)) for i in range(1, n): if not np.all(modes[i] == modes[i - 1]): guard_index.append(i) elif len(envs[i]) != 0: if not envs[i][0].is_same(envs[i - 1][0]): guard_index.append(i) elif not (mnps[i][0].is_same(mnps[i - 1][0]) and mnps[i][1].is_same(mnps[i - 1][1])): # manipulator change guard_index.append(i) g_v = np.identity(3) g_v[0:2, 0:2] = config2trans(path[i - 1])[0:2, 0:2] v_init[i - 1] = np.dot(g_v.T, np.array(path[i]) - np.array(path[i - 1])) #guard_index.append(len(modes)-1) guard_index = np.unique(guard_index) Gs = dict() hs = dict() As = dict() bs = dict() for i in range(len(path)): G, h, A, b = contact_mode_constraints(path[i], mnps[i], envs[i], modes[i], tree.world, tree.mnp_mu, tree.env_mu, tree.mnp_fn_max) gid = np.any(G[:, 0:3], axis=1) aid = np.any(A[:, 0:3], axis=1) Gs[i] = G[gid, 0:3] hs[i] = h[gid].flatten() As[i] = A[aid, 0:3] bs[i] = b[aid].flatten() modeconstraints = (Gs, hs, As, bs) q_goal = np.array(tree.x_goal) opt_prob = Optimization('Trajectory Optimization', obj_fun) x_init = np.hstack((np.array(path).flatten(), v_init.flatten())) cs = constraints(x_init, path, Gs, hs, As, bs, guard_index) opt_prob.addVarGroup('x', n * 6, 'c', value=x_init, lower=-10, upper=10) opt_prob.addObj('f') opt_prob.addConGroup('g', len(cs), 'i', lower=0.0, upper=10000.0) print(opt_prob) slsqp = SLSQP() #slsqp.setOption('IPRINT', -1) slsqp(opt_prob, sens_type='FD', goal=q_goal, path=path, modecons=modeconstraints, guard_index=guard_index) print(opt_prob.solution(0)) qs = [opt_prob.solution(0)._variables[i].value for i in range(n * 3)] return qs
def get_pyopt_optimization(f, g_f, con, g_con, x0, T): opt_prob = Optimization('stoc planner', obj_fun(f, con)) opt_prob.addObj('f') opt_prob.addVarGroup('flat_plan', x0.size, type='c', value = x0, lower = 0., upper = 1.0) opt_prob.addConGroup('g', T, 'e') # opt = SLSQP() # opt = pySNOPT.SNOPT() # opt = PSQP() # opt = CONMIN() opt = ALGENCAN() return opt_prob, opt
def runoptimizer(): opt_prob = Optimization('TP37 Constrained Problem',objfun) opt_prob.addObj('LL') opt_prob.addVar('x1','c',lower=0.01,upper=10.0,value=1.0) opt_prob.addVar('x2','c',lower=0.01,upper=10.0,value=1.0) opt_prob.addVar('x3','c',lower=0.01,upper=10.0,value=1.0) opt_prob.addVar('x4','c',lower=0.01,upper=10.0,value=1.0) opt_prob.addConGroup('g', 4, 'i') # sanity check print opt_prob print objfun([1.0,1.0,1.0,1.0]) # other optimization methods can be used here - we use sequential least squares programming slsqp = SLSQP() [fstr, xstr, inform] = slsqp(opt_prob) print opt_prob.solution(0) return [v.value for v in opt_prob.solution(0).getVarSet().values()]
def main(): ########################################### # Define some values ########################################### n_blades = 2 n_elements = 10 radius = unit_conversion.in2m(9.6) / 2 root_cutout = 0.1 * radius dy = float(radius - root_cutout) / n_elements dr = float(1) / n_elements y = root_cutout + dy * np.arange(1, n_elements + 1) r = y / radius pitch = 0.0 airfoils = (('SDA1075_494p', 0.0, 1.0), ) allowable_Re = [ 1000000., 500000., 250000., 100000., 90000., 80000., 70000., 60000., 50000., 40000., 30000., 20000., 10000. ] vehicle_weight = 12.455 max_chord = 0.3 max_chord_tip = 5. alt = 0 tip_loss = True mach_corr = False # Forward flight parameters v_inf = 4. # m/s alpha0 = 0.0454 # Starting guess for trimmed alpha in radians n_azi_elements = 5 # Mission times time_in_hover = 300. # Time in seconds time_in_ff = 500. mission_time = [time_in_hover, time_in_ff] Cl_tables = {} Cd_tables = {} Clmax = {} # Get lookup tables if any(airfoil[0] != 'simple' for airfoil in airfoils): for airfoil in airfoils: Cl_table, Cd_table, Clmax = aero_coeffs.create_Cl_Cd_table( airfoil[0]) Cl_tables[airfoil[0]] = Cl_table Cd_tables[airfoil[0]] = Cd_table Clmax[airfoil[0]] = Clmax # Create list of Cl functions. One for each Reynolds number. Cl_tables (and Cd_tables) will be empty for the # 'simple' case, therefore this will be skipped for the simple case. For the full table lookup case this will be # skipped because allowable_Re will be empty. Cl_funs = {} Cd_funs = {} lift_curve_info_dict = {} if Cl_tables and allowable_Re: Cl_funs = dict( zip(allowable_Re, [ aero_coeffs.get_Cl_fun(Re, Cl_tables[airfoils[0][0]], Clmax[airfoils[0][0]][Re]) for Re in allowable_Re ])) Cd_funs = dict( zip(allowable_Re, [ aero_coeffs.get_Cd_fun(Re, Cd_tables[airfoils[0][0]]) for Re in allowable_Re ])) lift_curve_info_dict = aero_coeffs.create_liftCurveInfoDict( allowable_Re, Cl_tables[airfoils[0][0]]) ########################################### # Set design variable bounds ########################################### # Hover opt 500 gen, 1000 pop, 12.455 N weight, 9.6 in prop chord = np.array([ 0.11923604, 0.2168746, 0.31540216, 0.39822882, 0.42919, 0.35039799, 0.3457828, 0.28567224, 0.23418368, 0.13502483 ]) twist = np.array([ 0.45316866, 0.38457724, 0.38225075, 0.34671967, 0.33151445, 0.28719111, 0.25679667, 0.25099005, 0.19400679, 0.10926302 ]) omega = 3811.03596674 * 2 * np.pi / 60 original = (omega, chord, twist) dtwist = np.array( [twist[i + 1] - twist[i] for i in xrange(len(twist) - 1)]) dchord = np.array( [chord[i + 1] - chord[i] for i in xrange(len(chord) - 1)]) twist0 = twist[0] chord0 = chord[0] omega_start = omega dtwist_start = dtwist dchord_start = dchord twist0_start = twist0 chord0_start = chord0 omega_lower = 2000 * 2 * np.pi / 60 omega_upper = 8000.0 * 2 * np.pi / 60 twist0_lower = 0. * 2 * np.pi / 360 twist0_upper = 60. * 2 * np.pi / 360 chord0_upper = 0.1198 chord0_lower = 0.05 dtwist_lower = -10.0 * 2 * np.pi / 360 dtwist_upper = 10.0 * 2 * np.pi / 360 dchord_lower = -0.1 dchord_upper = 0.1 opt_prob = Optimization('Mission Simulator', objfun) opt_prob.addVar('omega_h', 'c', value=omega_start, lower=omega_lower, upper=omega_upper) opt_prob.addVar('twist0', 'c', value=twist0_start, lower=twist0_lower, upper=twist0_upper) opt_prob.addVar('chord0', 'c', value=chord0_start, lower=chord0_lower, upper=chord0_upper) opt_prob.addVarGroup('dtwist', n_elements - 1, 'c', value=dtwist_start, lower=dtwist_lower, upper=dtwist_upper) opt_prob.addVarGroup('dchord', n_elements - 1, 'c', value=dchord_start, lower=dchord_lower, upper=dchord_upper) opt_prob.addObj('f') opt_prob.addCon('thrust', 'i') opt_prob.addCon('c_tip', 'i') opt_prob.addConGroup('c_lower', n_elements, 'i') opt_prob.addConGroup('c_upper', n_elements, 'i') print opt_prob slsqp = SLSQP() slsqp.setOption('IPRINT', 1) slsqp.setOption('MAXIT', 1000) slsqp.setOption('ACC', 1e-8) fstr, xstr, inform = slsqp(opt_prob, sens_type='FD', n_blades=n_blades, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, airfoils=airfoils, vehicle_weight=vehicle_weight, max_chord=max_chord, tip_loss=tip_loss, mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables, Cd_tables=Cd_tables, allowable_Re=allowable_Re, alt=alt, v_inf=v_inf, alpha0=alpha0, mission_time=mission_time, n_azi_elements=n_azi_elements, lift_curve_info_dict=lift_curve_info_dict, max_chord_tip=max_chord_tip) print opt_prob.solution(0) # pop_size = 300 # max_gen = 500 # opt_method = 'nograd' # nsga2 = NSGA2() # nsga2.setOption('PrintOut', 2) # nsga2.setOption('PopSize', pop_size) # nsga2.setOption('maxGen', max_gen) # nsga2.setOption('pCross_real', 0.85) # nsga2.setOption('xinit', 1) # fstr, xstr, inform = nsga2(opt_prob, n_blades=n_blades, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, # airfoils=airfoils, vehicle_weight=vehicle_weight, max_chord=max_chord, tip_loss=tip_loss, # mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables, # Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method, alt=alt, # v_inf=v_inf, alpha0=alpha0, mission_time=mission_time, n_azi_elements=n_azi_elements, # pop_size=pop_size, max_gen=max_gen, lift_curve_info_dict=lift_curve_info_dict, # max_chord_tip=max_chord_tip) # print opt_prob.solution(0) # opt_method = 'nograd' # xstart_alpso = np.concatenate((np.array([omega_start, twist0_start, chord0_start]), dtwist_start, dchord_start)) # alpso = ALPSO() # alpso.setOption('xinit', 0) # alpso.setOption('SwarmSize', 200) # alpso.setOption('maxOuterIter', 100) # alpso.setOption('stopCriteria', 0) # fstr, xstr, inform = alpso(opt_prob, xstart=xstart_alpso, n_blades=n_blades, n_elements=n_elements, # root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, # airfoils=airfoils, thrust=thrust, max_chord=max_chord, tip_loss=tip_loss, # mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables, # Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method) # print opt_prob.solution(0) def get_performance(o, c, t): chord_meters = c * radius prop = propeller.Propeller(t, chord_meters, radius, n_blades, r, y, dr, dy, airfoils=airfoils, Cl_tables=Cl_tables, Cd_tables=Cd_tables) quad = quadrotor.Quadrotor(prop, vehicle_weight) ff_kwargs = { 'propeller': prop, 'pitch': pitch, 'n_azi_elements': n_azi_elements, 'allowable_Re': allowable_Re, 'Cl_funs': Cl_funs, 'Cd_funs': Cd_funs, 'tip_loss': tip_loss, 'mach_corr': mach_corr, 'alt': alt, 'lift_curve_info_dict': lift_curve_info_dict } trim0 = np.array([alpha0, o]) alpha_trim, omega_trim, converged = trim.trim(quad, v_inf, trim0, ff_kwargs) T_ff, H_ff, P_ff = bemt.bemt_forward_flight( quad, pitch, omega_trim, alpha_trim, v_inf, n_azi_elements, alt=alt, tip_loss=tip_loss, mach_corr=mach_corr, allowable_Re=allowable_Re, Cl_funs=Cl_funs, Cd_funs=Cd_funs, lift_curve_info_dict=lift_curve_info_dict) dT_h, P_h = bemt.bemt_axial(prop, pitch, o, allowable_Re=allowable_Re, Cl_funs=Cl_funs, Cd_funs=Cd_funs, tip_loss=tip_loss, mach_corr=mach_corr, alt=alt) return sum(dT_h), P_h, T_ff, P_ff, alpha_trim, omega_trim omega = xstr[0] twist0 = xstr[1] chord0 = xstr[2] dtwist = xstr[3:3 + len(r) - 1] dchord = xstr[3 + len(r) - 1:] twist = calc_twist_dist(twist0, dtwist) chord = calc_chord_dist(chord0, dchord) print "chord = " + repr(chord) print "twist = " + repr(twist) # twist_base = calc_twist_dist(twist0_base, dtwist_base) # chord_base = calc_chord_dist(chord0_base, dchord_base) perf_opt = get_performance(omega, chord, twist) perf_orig = get_performance(original[0], original[1], original[2]) print "omega_orig = " + str(original[0]) print "Hover Thrust of original = " + str(perf_orig[0]) print "Hover Power of original = " + str(perf_orig[1]) print "FF Thrust of original = " + str(perf_orig[2]) print "FF Power of original = " + str(perf_orig[3]) print "Trim original (alpha, omega) = (%f, %f)" % (perf_orig[4], perf_orig[5]) print "omega = " + str(omega * 60 / 2 / np.pi) print "Hover Thrust of optimized = " + str(perf_opt[0]) print "Hover Power of optimized = " + str(perf_opt[1]) print "FF Thrust of optimized = " + str(perf_opt[2]) print "FF Power of optimized = " + str(perf_opt[3]) print "Trim optimized (alpha, omega) = (%f, %f)" % (perf_opt[4], perf_opt[5]) # print "Omega base = " + str(omega_start*60/2/np.pi) # print "Thrust of base = " + str(sum(perf_base[0])) # print "Power of base = " + str(sum(perf_base[1])) # plt.figure(1) plt.plot(r, original[1], '-b') plt.plot(r, chord, '-r') plt.xlabel('radial location') plt.ylabel('c/R') plt.legend(['start', 'opt']) plt.figure(2) plt.plot(r, original[2] * 180 / np.pi, '-b') plt.plot(r, twist * 180 / np.pi, '-r') plt.xlabel('radial location') plt.ylabel('twist') plt.legend(['start', 'opt']) plt.show()
def optimizeTrajectory(self, plot_func=None): # use non-linear optimization to find parameters for minimal # condition number trajectory self.plot_func = plot_func if self.config['showOptimizationGraph']: self.initGraph() ## describe optimization problem with pyOpt classes from pyOpt import Optimization from pyOpt import ALPSO, SLSQP # Instanciate Optimization Problem opt_prob = Optimization('Trajectory optimization', self.objective_func) opt_prob.addObj('f') # add variables, define bounds # w_f - pulsation opt_prob.addVar('wf', 'c', value=self.wf_init, lower=self.wf_min, upper=self.wf_max) # q - offsets for i in range(self.dofs): opt_prob.addVar('q_%d'%i,'c', value=self.qinit[i], lower=self.qmin[i], upper=self.qmax[i]) # a, b - sin/cos params for i in range(self.dofs): for j in range(self.nf[0]): opt_prob.addVar('a{}_{}'.format(i,j), 'c', value=self.ainit[i][j], lower=self.amin, upper=self.amax) for i in range(self.dofs): for j in range(self.nf[0]): opt_prob.addVar('b{}_{}'.format(i,j), 'c', value=self.binit[i][j], lower=self.bmin, upper=self.bmax) # add constraint vars (constraint functions are in obfunc) if self.config['minVelocityConstraint']: opt_prob.addConGroup('g', self.dofs*5, 'i') else: opt_prob.addConGroup('g', self.dofs*4, 'i') #print opt_prob initial = [v.value for v in list(opt_prob._variables.values())] if self.config['useGlobalOptimization']: ### optimize using pyOpt (global) opt = ALPSO() #augmented lagrange particle swarm optimization opt.setOption('stopCriteria', 0) opt.setOption('maxInnerIter', 3) opt.setOption('maxOuterIter', self.config['globalOptIterations']) opt.setOption('printInnerIters', 1) opt.setOption('printOuterIters', 1) opt.setOption('SwarmSize', 30) opt.setOption('xinit', 1) #TODO: how to properly limit max number of function calls? # no. func calls = (SwarmSize * inner) * outer + SwarmSize self.iter_max = opt.getOption('SwarmSize') * opt.getOption('maxInnerIter') * opt.getOption('maxOuterIter') + opt.getOption('SwarmSize') # run fist (global) optimization try: #reuse history opt(opt_prob, store_hst=False, hot_start=True, xstart=initial) except NameError: opt(opt_prob, store_hst=False, xstart=initial) print(opt_prob.solution(0)) ### pyOpt local # after using global optimization, get more exact solution with # gradient based method init optimizer (only local) opt2 = SLSQP() #sequential least squares opt2.setOption('MAXIT', self.config['localOptIterations']) if self.config['verbose']: opt2.setOption('IPRINT', 0) # TODO: amount of function calls depends on amount of variables and iterations to approximate gradient # iterations are probably steps along the gradient. How to get proper no. of func calls? self.iter_max = "(unknown)" if self.config['useGlobalOptimization']: if self.last_best_sol is not None: #use best constrained solution for i in range(len(opt_prob._variables)): opt_prob._variables[i].value = self.last_best_sol[i] else: #reuse previous solution for i in range(len(opt_prob._variables)): opt_prob._variables[i].value = opt_prob.solution(0).getVar(i).value opt2(opt_prob, store_hst=False, sens_step=0.1) else: try: #reuse history opt2(opt_prob, store_hst=True, hot_start=True, sens_step=0.1) except NameError: opt2(opt_prob, store_hst=True, sens_step=0.1) local_sol = opt_prob.solution(0) if not self.config['useGlobalOptimization']: print(local_sol) local_sol_vec = np.array([local_sol.getVar(x).value for x in range(0,len(local_sol._variables))]) if self.last_best_sol is not None: local_sol_vec = self.last_best_sol print("using last best constrained solution instead of given solver solution.") sol_wf, sol_q, sol_a, sol_b = self.vecToParams(local_sol_vec) print("testing final solution") self.iter_cnt = 0 self.objective_func(local_sol_vec) print("\n") self.trajectory.initWithParams(sol_a, sol_b, sol_q, self.nf, sol_wf) if self.config['showOptimizationGraph']: plt.ioff() return self.trajectory
return f, g, fail # ============================================================================= # Run the NSGA Optimizer # ============================================================================= #Define the lower and upper bounds for R LB = [500] * nvar UB = [9000] * nvar InitR = [] for i in range(nvar): InitR.append(random.randint(1500, 9000)) opt_prob = Optimization('Reservoir Operations Optimization', benefit) opt_prob.addVarGroup('x', nvar, 'c', lower=LB, upper=UB, value=InitR) opt_prob.addObj('f') opt_prob.addConGroup('g', nvar * 3, 'i') # 3 inequality constraints Smin, Smax, Hmin # Instantiate Optimizer (NSGA2) & Solve Problem nsga2 = NSGA2() nsga2.setOption('PrintOut', 0) nsga2.setOption('PopSize', 1000) nsga2.setOption('maxGen', 150) nsga2.setOption('pMut_real', 0.075) nsga2(opt_prob) print "Optimization Completed Successfully!" a = opt_prob.solution(0) print a Ropt = [] for i in range(nvar): sf = str(a.getVar(i))
def optimize_chord(**k): omega = k['omega'] omega_lower = k['omega_lower'] omega_upper = k['omega_upper'] chord0 = k['chord0'] chord0_lower = k['chord0_lower'] chord0_upper = k['chord0_upper'] n_elements = k['n_elements'] dchord = k['dchord'] dchord_lower = k['dchord_lower'] dchord_upper = k['dchord_upper'] opt_prob_ft = Optimization('Rotor in Hover w/ Fixed Twist', objfun_optimize_chord) opt_prob_ft.addVar('omega', 'c', value=omega, lower=omega_lower, upper=omega_upper) opt_prob_ft.addVar('chord0', 'c', value=chord0, lower=chord0_lower, upper=chord0_upper) opt_prob_ft.addVarGroup('dchord', n_elements - 1, 'c', value=dchord, lower=dchord_lower, upper=dchord_upper) opt_prob_ft.addObj('f') opt_prob_ft.addCon('thrust', 'i') opt_prob_ft.addConGroup('c_lower', n_elements, 'i') opt_prob_ft.addConGroup('c_upper', n_elements, 'i') n_blades = k['n_blades'] root_cutout = k['root_cutout'] radius = k['radius'] dy = k['dy'] dr = k['dr'] y = k['y'] r = k['r'] pitch = k['pitch'] airfoils = k['airfoils'] thrust = k['thrust'] max_chord = k['max_chord'] twist = k['twist'] allowable_Re = k['allowable_Re'] Cl_tables = k['Cl_tables'] Cd_tables = k['Cd_tables'] Cl_funs = k['Cl_funs'] Cd_funs = k['Cd_funs'] tip_loss = k['tip_loss'] mach_corr = k['mach_corr'] alt = k['alt'] # Routine for optimizing chord with constant twist slsqp1 = SLSQP() slsqp1.setOption('IPRINT', 1) slsqp1.setOption('MAXIT', 200) slsqp1.setOption('ACC', 1e-7) fstr, xstr, inform = slsqp1(opt_prob_ft, sens_type='FD', n_blades=n_blades, n_elements=n_elements, root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, airfoils=airfoils, thrust=thrust, max_chord=max_chord, tip_loss=tip_loss, mach_corr=mach_corr, omega=omega, twist=twist, allowable_Re=allowable_Re, Cl_tables=Cl_tables, Cd_tables=Cd_tables, Cl_funs=Cl_funs, Cd_funs=Cd_funs, alt=alt) return fstr, xstr
def main(): ########################################### # Define some values ########################################### n_blades = 2 n_elements = 10 radius = unit_conversion.in2m(9.6) / 2 root_cutout = 0.1 * radius dy = float(radius - root_cutout) / n_elements dr = float(1) / n_elements y = root_cutout + dy * np.arange(1, n_elements + 1) r = y / radius pitch = 0.0 airfoils = (('SDA1075_494p', 0.0, 1.0), ) #allowable_Re = [] allowable_Re = [ 1000000., 500000., 250000., 100000., 90000., 80000., 70000., 60000., 50000., 40000., 30000., 20000., 10000. ] vehicle_weight = 12.455 max_chord = 0.6 max_chord_tip = 5. alt = 0 tip_loss = True mach_corr = False # Forward flight parameters v_inf = 4. # m/s alpha0 = 0.0454 # Starting guess for trimmed alpha in radians n_azi_elements = 5 # Mission times time_in_hover = 0. # Time in seconds time_in_ff = 500. mission_time = [time_in_hover, time_in_ff] Cl_tables = {} Cd_tables = {} Clmax = {} # Get lookup tables if any(airfoil[0] != 'simple' for airfoil in airfoils): for airfoil in airfoils: Cl_table, Cd_table, Clmax = aero_coeffs.create_Cl_Cd_table( airfoil[0]) Cl_tables[airfoil[0]] = Cl_table Cd_tables[airfoil[0]] = Cd_table Clmax[airfoil[0]] = Clmax # Create list of Cl functions. One for each Reynolds number. Cl_tables (and Cd_tables) will be empty for the # 'simple' case, therefore this will be skipped for the simple case. For the full table lookup case this will be # skipped because allowable_Re will be empty. Cl_funs = {} Cd_funs = {} lift_curve_info_dict = {} if Cl_tables and allowable_Re: Cl_funs = dict( zip(allowable_Re, [ aero_coeffs.get_Cl_fun(Re, Cl_tables[airfoils[0][0]], Clmax[airfoils[0][0]][Re]) for Re in allowable_Re ])) Cd_funs = dict( zip(allowable_Re, [ aero_coeffs.get_Cd_fun(Re, Cd_tables[airfoils[0][0]]) for Re in allowable_Re ])) lift_curve_info_dict = aero_coeffs.create_liftCurveInfoDict( allowable_Re, Cl_tables[airfoils[0][0]]) ########################################### # Set design variable bounds ########################################### omega_start = 4250. * 2 * np.pi / 60 # These are c/R values for the DA4002 propeller given at the UIUC propeller database chord_base = np.array([ 0.1198, 0.1128, 0.1436, 0.1689, 0.1775, 0.1782, 0.1773, 0.1782, 0.1790, 0.1787, 0.1787, 0.1786, 0.1785, 0.1790, 0.1792, 0.1792, 0.1692, 0.0154 ]) chord_base = np.array( [chord_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]]) twist_base = np.array([ 42.481, 44.647, 41.154, 37.475, 34.027, 30.549, 27.875, 25.831, 23.996, 22.396, 21.009, 19.814, 18.786, 17.957, 17.245, 16.657, 13.973, 2.117 ]) * 2 * np.pi / 360 twist_base = np.array( [twist_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]]) dtwist_base = np.array([ twist_base[i + 1] - twist_base[i] for i in xrange(len(twist_base) - 1) ]) dchord_base = np.array([ chord_base[i + 1] - chord_base[i] for i in xrange(len(chord_base) - 1) ]) twist0_base = twist_base[0] chord0_base = chord_base[0] chord_start = chord_base twist_start = twist_base dtwist_start = dtwist_base dchord_start = dchord_base twist0_start = twist0_base chord0_start = chord0_base print "chord0_start = " + str(chord0_start) omega_lower = 2000 * 2 * np.pi / 60 omega_upper = 8000.0 * 2 * np.pi / 60 twist0_lower = 0. * 2 * np.pi / 360 twist0_upper = 60. * 2 * np.pi / 360 chord0_upper = 0.1198 chord0_lower = 0.05 dtwist_lower = -10.0 * 2 * np.pi / 360 dtwist_upper = 10.0 * 2 * np.pi / 360 dchord_lower = -0.1 dchord_upper = 0.1 opt_prob = Optimization('Mission Simulator', objfun) opt_prob.addVar('omega_h', 'c', value=omega_start, lower=omega_lower, upper=omega_upper) opt_prob.addVar('twist0', 'c', value=twist0_start, lower=twist0_lower, upper=twist0_upper) opt_prob.addVar('chord0', 'c', value=chord0_start, lower=chord0_lower, upper=chord0_upper) opt_prob.addVarGroup('dtwist', n_elements - 1, 'c', value=dtwist_start, lower=dtwist_lower, upper=dtwist_upper) opt_prob.addVarGroup('dchord', n_elements - 1, 'c', value=dchord_start, lower=dchord_lower, upper=dchord_upper) opt_prob.addObj('f') opt_prob.addCon('thrust', 'i') opt_prob.addCon('c_tip', 'i') opt_prob.addConGroup('c_lower', n_elements, 'i') opt_prob.addConGroup('c_upper', n_elements, 'i') print opt_prob pop_size = 300 max_gen = 1100 opt_method = 'nograd' nsga2 = NSGA2() nsga2.setOption('PrintOut', 2) nsga2.setOption('PopSize', pop_size) nsga2.setOption('maxGen', max_gen) nsga2.setOption('pCross_real', 0.85) nsga2.setOption('pMut_real', 0.2) nsga2.setOption('xinit', 1) fstr, xstr, inform = nsga2(opt_prob, n_blades=n_blades, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, airfoils=airfoils, vehicle_weight=vehicle_weight, max_chord=max_chord, tip_loss=tip_loss, mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables, Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method, alt=alt, v_inf=v_inf, alpha0=alpha0, mission_time=mission_time, n_azi_elements=n_azi_elements, pop_size=pop_size, max_gen=max_gen, lift_curve_info_dict=lift_curve_info_dict, max_chord_tip=max_chord_tip) print opt_prob.solution(0) # opt_method = 'nograd' # xstart_alpso = np.concatenate((np.array([omega_start, twist0_start, chord0_start]), dtwist_start, dchord_start)) # alpso = ALPSO() # alpso.setOption('xinit', 0) # alpso.setOption('SwarmSize', 200) # alpso.setOption('maxOuterIter', 100) # alpso.setOption('stopCriteria', 0) # fstr, xstr, inform = alpso(opt_prob, xstart=xstart_alpso, n_blades=n_blades, n_elements=n_elements, # root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, # airfoils=airfoils, thrust=thrust, max_chord=max_chord, tip_loss=tip_loss, # mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables, # Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method) # print opt_prob.solution(0) # opt_method = 'grad' # slsqp = SLSQP() # slsqp.setOption('IPRINT', 1) # slsqp.setOption('MAXIT', 1000) # slsqp.setOption('ACC', 1e-7) # fstr, xstr, inform = slsqp(opt_prob, sens_type='FD', n_blades=n_blades, n_elements=n_elements, # root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, # airfoils=airfoils, thrust=thrust, max_chord=max_chord, # tip_loss=tip_loss, mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, # Cl_tables=Cl_tables, Cd_tables=Cd_tables, allowable_Re=allowable_Re, # opt_method=opt_method, alt=alt) # print opt_prob.solution(0) def get_performance(o, c, t): chord_meters = c * radius prop = propeller.Propeller(t, chord_meters, radius, n_blades, r, y, dr, dy, airfoils=airfoils, Cl_tables=Cl_tables, Cd_tables=Cd_tables) quad = quadrotor.Quadrotor(prop, vehicle_weight) ff_kwargs = { 'propeller': prop, 'pitch': pitch, 'n_azi_elements': n_azi_elements, 'allowable_Re': allowable_Re, 'Cl_funs': Cl_funs, 'Cd_funs': Cd_funs, 'tip_loss': tip_loss, 'mach_corr': mach_corr, 'alt': alt, 'lift_curve_info_dict': lift_curve_info_dict } trim0 = np.array([alpha0, o]) alpha_trim, omega_trim, converged = trim.trim(quad, v_inf, trim0, ff_kwargs) T_ff, H_ff, P_ff = bemt.bemt_forward_flight( quad, pitch, omega_trim, alpha_trim, v_inf, n_azi_elements, alt=alt, tip_loss=tip_loss, mach_corr=mach_corr, allowable_Re=allowable_Re, Cl_funs=Cl_funs, Cd_funs=Cd_funs, lift_curve_info_dict=lift_curve_info_dict) dT_h, P_h = bemt.bemt_axial(prop, pitch, o, allowable_Re=allowable_Re, Cl_funs=Cl_funs, Cd_funs=Cd_funs, tip_loss=tip_loss, mach_corr=mach_corr, alt=alt) return sum(dT_h), P_h, T_ff, P_ff, alpha_trim, omega_trim omega = xstr[0] twist0 = xstr[1] chord0 = xstr[2] dtwist = xstr[3:3 + len(r) - 1] dchord = xstr[3 + len(r) - 1:] twist = calc_twist_dist(twist0, dtwist) chord = calc_chord_dist(chord0, dchord) print "chord = " + repr(chord) print "twist = " + repr(twist) # twist_base = calc_twist_dist(twist0_base, dtwist_base) # chord_base = calc_chord_dist(chord0_base, dchord_base) perf_opt = get_performance(omega, chord, twist) #perf_base = get_performance(omega_start, chord_base, twist_base) print "omega = " + str(omega * 60 / 2 / np.pi) print "Hover Thrust of optimized = " + str(perf_opt[0]) print "Hover Power of optimized = " + str(perf_opt[1]) print "FF Thrust of optimized = " + str(perf_opt[2]) print "FF Power of optimized = " + str(perf_opt[3]) print "Trim (alpha, omega) = (%f, %f)" % (perf_opt[4], perf_opt[5])
def main(): ########################################### # Define some values ########################################### n_blades = 2 n_elements = 10 radius = unit_conversion.in2m(9.6) / 2 #radius = 0.1397 root_cutout = 0.1 * radius dy = float(radius - root_cutout) / n_elements dr = float(1) / n_elements y = root_cutout + dy * np.arange(1, n_elements + 1) r = y / radius pitch = 0.0 airfoils = (('SDA1075_494p', 0.0, 1.0), ) #allowable_Re = [] allowable_Re = [ 1000000., 500000., 250000., 100000., 90000., 80000., 70000., 60000., 50000., 40000., 30000., 20000., 10000. ] vehicle_weight = 12.455 max_chord = 0.6 alt = 0 tip_loss = True mach_corr = False Cl_tables = {} Cd_tables = {} Clmax = {} # Get lookup tables if any(airfoil[0] != 'simple' for airfoil in airfoils): for airfoil in airfoils: Cl_table, Cd_table, Clmax = aero_coeffs.create_Cl_Cd_table( airfoil[0]) Cl_tables[airfoil[0]] = Cl_table Cd_tables[airfoil[0]] = Cd_table Clmax[airfoil[0]] = Clmax # Create list of Cl functions. One for each Reynolds number. Cl_tables (and Cd_tables) will be empty for the # 'simple' case, therefore this will be skipped for the simple case. For the full table lookup case this will be # skipped because allowable_Re will be empty. Cl_funs = {} Cd_funs = {} lift_curve_info_dict = {} if Cl_tables and allowable_Re: Cl_funs = dict( zip(allowable_Re, [ aero_coeffs.get_Cl_fun(Re, Cl_tables[airfoils[0][0]], Clmax[airfoils[0][0]][Re]) for Re in allowable_Re ])) Cd_funs = dict( zip(allowable_Re, [ aero_coeffs.get_Cd_fun(Re, Cd_tables[airfoils[0][0]]) for Re in allowable_Re ])) lift_curve_info_dict = aero_coeffs.create_liftCurveInfoDict( allowable_Re, Cl_tables[airfoils[0][0]]) ########################################### # Set design variable bounds ########################################### omega_start = 4250. * 2 * np.pi / 60 chord_base = np.array([ 0.1198, 0.1128, 0.1436, 0.1689, 0.1775, 0.1782, 0.1773, 0.1782, 0.1790, 0.1787, 0.1787, 0.1786, 0.1785, 0.1790, 0.1792, 0.1792, 0.1692, 0.0154 ]) chord_base = np.array( [chord_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]]) twist_base = np.array([ 42.481, 44.647, 41.154, 37.475, 34.027, 30.549, 27.875, 25.831, 23.996, 22.396, 21.009, 19.814, 18.786, 17.957, 17.245, 16.657, 13.973, 2.117 ]) * 2 * np.pi / 360 twist_base = np.array( [twist_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]]) dtwist_base = np.array([ twist_base[i + 1] - twist_base[i] for i in xrange(len(twist_base) - 1) ]) dchord_base = np.array([ chord_base[i + 1] - chord_base[i] for i in xrange(len(chord_base) - 1) ]) twist0_base = twist_base[0] chord0_base = chord_base[0] chord_start = chord_base twist_start = twist_base dtwist_start = dtwist_base dchord_start = dchord_base twist0_start = twist0_base chord0_start = chord0_base # chord = np.array([8.92386048e-02, 1.73000845e-01, 2.70523039e-01, 2.71542807e-01, 2.78749355e-01, 2.36866151e-01, # 2.04103526e-01, 1.37456074e-01, 8.68094589e-02, 1.05601135e-04]) # twist = np.array([0.00161645, 0.15105685, 0.28791442, 0.31577392, 0.28644651, 0.27418749, 0.24854514, 0.21812646, # 0.19802027, 0.14972058]) # omega_start = 3184.41320387 * 2*np.pi/60 # chord_start = chord # twist_start = twist # dchord_start = np.array([chord[i+1]-chord[i] for i in xrange(len(chord)-1)]) # dtwist_start = np.array([twist[i+1]-twist[i] for i in xrange(len(twist)-1)]) # twist0_start = twist[0] # chord0_start = chord[0] ## Initialize everything to zeros # dtwist_start = np.zeros(n_elements-1) # dchord_start = np.zeros(n_elements-1) # twist0_start = 0.0 # chord0_start = 0.0 omega_lower = 2000 * 2 * np.pi / 60 omega_upper = 8000.0 * 2 * np.pi / 60 twist0_lower = 0.0 * 2 * np.pi / 360 twist0_upper = 60. * 2 * np.pi / 360 chord0_upper = 0.1198 chord0_lower = 0.05 dtwist_lower = -10.0 * 2 * np.pi / 360 dtwist_upper = 10.0 * 2 * np.pi / 360 dchord_lower = -0.1 dchord_upper = 0.1 opt_prob = Optimization('Rotor in Hover', objfun) opt_prob.addVar('omega', 'c', value=omega_start, lower=omega_lower, upper=omega_upper) opt_prob.addVar('twist0', 'c', value=twist0_start, lower=twist0_lower, upper=twist0_upper) opt_prob.addVar('chord0', 'c', value=chord0_start, lower=chord0_lower, upper=chord0_upper) opt_prob.addVarGroup('dtwist', n_elements - 1, 'c', value=dtwist_start, lower=dtwist_lower, upper=dtwist_upper) opt_prob.addVarGroup('dchord', n_elements - 1, 'c', value=dchord_start, lower=dchord_lower, upper=dchord_upper) opt_prob.addObj('f') opt_prob.addCon('thrust', 'i') opt_prob.addConGroup('c_lower', n_elements, 'i') opt_prob.addConGroup('c_upper', n_elements, 'i') print opt_prob opt_method = 'nograd' nsga2 = NSGA2() nsga2.setOption('PrintOut', 2) nsga2.setOption('PopSize', 300) nsga2.setOption('maxGen', 1100) nsga2.setOption('pCross_real', 0.85) nsga2.setOption('xinit', 1) fstr, xstr, inform = nsga2(opt_prob, n_blades=n_blades, n_elements=n_elements, root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, airfoils=airfoils, vehicle_weight=vehicle_weight, max_chord=max_chord, tip_loss=tip_loss, mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables, Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method, alt=alt, lift_curve_info_dict=lift_curve_info_dict) print opt_prob.solution(0) # opt_method = 'nograd' # xstart_alpso = np.concatenate((np.array([omega_start, twist0_start, chord0_start]), dtwist_start, dchord_start)) # alpso = ALPSO() # alpso.setOption('xinit', 0) # alpso.setOption('SwarmSize', 200) # alpso.setOption('maxOuterIter', 100) # alpso.setOption('stopCriteria', 0) # fstr, xstr, inform = alpso(opt_prob, xstart=xstart_alpso, n_blades=n_blades, n_elements=n_elements, # root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, # airfoils=airfoils, thrust=thrust, max_chord=max_chord, tip_loss=tip_loss, # mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables, # Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method) # print opt_prob.solution(0) # opt_method = 'grad' # slsqp = SLSQP() # slsqp.setOption('IPRINT', 1) # slsqp.setOption('MAXIT', 1000) # slsqp.setOption('ACC', 1e-7) # fstr, xstr, inform = slsqp(opt_prob, sens_type='FD', n_blades=n_blades, n_elements=n_elements, # root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch, # airfoils=airfoils, thrust=thrust, max_chord=max_chord, # tip_loss=tip_loss, mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, # Cl_tables=Cl_tables, Cd_tables=Cd_tables, allowable_Re=allowable_Re, # opt_method=opt_method, alt=alt) # print opt_prob.solution(0) def get_performance(o, c, t): chord_meters = c * radius prop = propeller.Propeller(t, chord_meters, radius, n_blades, r, y, dr, dy, airfoils=airfoils, Cl_tables=Cl_tables, Cd_tables=Cd_tables) return bemt.bemt_axial(prop, pitch, o, allowable_Re=allowable_Re, Cl_funs=Cl_funs, Cd_funs=Cd_funs, tip_loss=tip_loss, mach_corr=mach_corr, output='long', alt=alt) omega = xstr[0] twist0 = xstr[1] chord0 = xstr[2] dtwist = xstr[3:3 + len(r) - 1] dchord = xstr[3 + len(r) - 1:] twist = calc_twist_dist(twist0, dtwist) chord = calc_chord_dist(chord0, dchord) print "chord = " + repr(chord) print "twist = " + repr(twist) # twist_base = calc_twist_dist(twist0_base, dtwist_base) # chord_base = calc_chord_dist(chord0_base, dchord_base) perf_opt = get_performance(omega, chord, twist) #perf_base = get_performance(omega_start, chord_base, twist_base) print "omega = " + str(omega * 60 / 2 / np.pi) print "Thrust of optimized = " + str(sum(perf_opt[0])) print "Power of optimized = " + str(perf_opt[1]) # print "Omega base = " + str(omega_start*60/2/np.pi) # print "Thrust of base = " + str(sum(perf_base[0])) # print "Power of base = " + str(sum(perf_base[1])) plt.figure(1) plt.plot(r, chord_start, '-b') plt.plot(r, chord, '-r') plt.xlabel('radial location') plt.ylabel('c/R') plt.legend(['start', 'opt']) plt.figure(2) plt.plot(r, twist_start * 180 / np.pi, '-b') plt.plot(r, twist * 180 / np.pi, '-r') plt.xlabel('radial location') plt.ylabel('twist') plt.legend(['start', 'opt']) plt.show()
ITMC.MCbase(Expense_list, w_initial, cycle)).xtvar(alpha) - Ityt.Uwg( ITMC.MCbase(Premium_list, w1, cycle), ITMC.MCbase(Loss_list, w1, cycle), ITMC.MCbase(Expense_list, w1, cycle)).xtvar(alpha) fail = 0 print 'obj_value : ', f, ' variable : ', w1 print 'penalty(negative value is valid) : ', g[0], g[1] return f, g, fail opt_prob = Optimization('Insurance Portfolio Optimization', obj_func_PSO) # There is a problem in variable type 'Discrete' wlen = len(w_lower) for w_low, w_high, i in zip(w_lower, w_upper, range(wlen)): opt_prob.addVar(weight_list[i], type='i', value=0., lower=-1., upper=1.) opt_prob.addObj('f') opt_prob.addConGroup('g', 2, type='i') # todo : ALPSO parmetor setting def alpso_wrapper(opt_prob): alpso = ALPSO() alpso.setOption('SwarmSize', 10) # default 40 -> 150 alpso.setOption('maxOuterIter', 5) # defualt 200 # alpso.setOption('rinit', 1.) # penalty factor alpso.setOption('fileout', 0) alpso.setOption('stopCriteria', 0) return alpso(opt_prob) def alpso_func(opt_prob): temp = alpso(opt_prob)
from pyOpt import CONMIN def obj_fun(x): f = x[0]**2 - 5 * x[0] + x[1]**2 - 5 * x[1] + 2 * x[2]**2 - 21 * x[2] + x[ 3]**2 + 7 * x[3] + 50 g = [0] * 3 g[0] = x[0]**2 + x[0] + x[1]**2 - x[1] + x[2]**2 + x[2] + x[3]**2 - x[3] - 8 g[1] = x[1]**2 - x[0] + 2 * x[1]**2 + x[2]**2 + 2 * x[3]**2 - x[3] - 10 g[2] = 2 * x[0]**2 + 2 * x[0] + x[1]**2 - x[1] + x[2]**2 - x[3] - 5 fail = 0 return f, g, fail xinit = [1.0, 1.0, 1.0, 1.0] opt_prob = Optimization('Rosen-Suzuki Constrained Minimization', obj_fun) opt_prob.addVarGroup('x', 4, 'c', value=xinit) opt_prob.addConGroup('g', 3, 'i') opt_prob.addObj('f') print opt_prob conmin = CONMIN() conmin.setOption('IPRINT', 1) conmin(opt_prob) print opt_prob.solution(0)