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
Пример #2
0
def solveOpt(int_domain,J,x,model,u0):
    def objfun(u,**kwargs):
        # 1) extract paraeters
        int_domain = kwargs['int_domain'] 
        J = kwargs['J'] 
        x = kwargs['x'] 
        model = kwargs['model'] 
        # 2) define objective function
        f = np.trapz(int_domain,J * model.pf(int_domain,u,x))
        g = [0]*2
        # 3) budget constraint 
        g[1] = u.sum() - 1
        # 4) VaR constarint
        W = model.W
        sigmaMax = model.VaR / norm.ppf(1-model.alpha)
        g[0] = -sigmaMax + np.sqrt(W.dot(u).dot(u))
        fail = 0
        return f,g,fail
    opt_prob = Optimization('test problem',objfun)
    opt_prob.addObj('f')
    opt_prob.addCon('budget const','e')    
    opt_prob.addCon('VaR const','i')
    opt_prob.addVarGroup('u',model.M,'c',lower=np.zeros(model.M),
                         upper=np.ones(model.M),value=u0)
    print opt_prob
    slsqp = SLSQP()
    slsqp.setOption('IPRINT',-1)
    slsqp(opt_prob,sens_type='FD',int_domain=int_domain,J=J,x=x,model=model)
    print opt_prob.solution(0)
    

      
    
    
Пример #3
0
def solveOpt(int_domain, J, a, model, u0, sign):
    '''
    INPUT:
        int_domain = 
        J = 
        a = 
        model = 
        u0 =
        sign = 
    OUTPUT:
        opt_prob = 
    '''
    def objfun(u, **kwargs):
        '''objfun defines the objective function and the constraints (equality
        and inequality) of the optiization problem'''
        # 1) extract paraeters
        int_domain = kwargs['int_domain']
        J = kwargs['J']
        x = kwargs['a']
        model = kwargs['model']
        sign = kwargs['sign']
        # 2) define objective function
        funz = np.trapz(x=int_domain, y=J * model.pf(int_domain, u, x))
        g = [0] * 2
        # 3) budget constraint
        g[0] = u.sum() - 1
        # 4) VaR constarint
        W = model.W
        sigmaMax = model.VaR / norm.ppf(1 - model.alpha)
        g[1] = -sigmaMax + np.sqrt(W.dot(u).dot(u))
        fail = 0
        return sign * funz, g, fail

    opt_prob = Optimization('ODAA problem', objfun)
    opt_prob.addObj('funz')
    opt_prob.addCon('budget const', 'e')
    opt_prob.addCon('VaR const', 'i')
    slsqp = SLSQP()  # instantiate Optimizer
    slsqp.setOption('IPRINT', -1)
    opt_prob.addVarGroup('u',
                         model.M,
                         'c',
                         lower=np.zeros(model.M),
                         upper=np.ones(model.M),
                         value=u0)
    #print opt_prob # print optimization problem
    slsqp(opt_prob,
          sens_type='FD',
          int_domain=int_domain,
          J=J,
          a=a,
          model=model,
          sign=sign)
    #print opt_prob.solution(0) # print solution
    return opt_prob
Пример #4
0
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 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()
Пример #6
0
    g = [0.0]*2
    g[0] = 3 - x0
    g[1] = 2 - x1
    
    fail = 0
    
    return f,g,fail
    

# =============================================================================
# 
# ============================================================================= 

# Instantiate Optimization Problem
opt_prob = Optimization('TOY Constrained Problem',objfunc,use_groups=True)
opt_prob.addVarGroup('a',2,'c',value=1.0, lower=0.0, upper=10)
opt_prob.delVarGroup('a')
opt_prob.addVar('x','c',value=1.0, lower=0.0, upper=10)
opt_prob.addVarGroup('y',2,'c',value=1.0, lower=0.0, upper=10)
opt_prob.delVarGroup('y')
opt_prob.addVarGroup('z',1,'c',value=1.0, lower=0.0, upper=10)
opt_prob.addVarGroup('b',5,'c',value=3.0, lower=0.0, upper=10)
opt_prob.delVarGroup('b')
opt_prob.addObj('f')
opt_prob.addCon('g1','i')
opt_prob.addCon('g2','i')
print(opt_prob)

# Instantiate Optimizer (SLSQP) & Solve Problem
slsqp = SLSQP()
slsqp(opt_prob)
Пример #7
0
    g = [0.0] * 2
    g[0] = 3 - x0
    g[1] = 2 - x1

    fail = 0

    return f, g, fail


# =============================================================================
#
# =============================================================================

# Instantiate Optimization Problem
opt_prob = Optimization('TOY Constraint Problem', objfunc, use_groups=True)
opt_prob.addVarGroup('a', 2, 'c', value=1.0, lower=0.0, upper=10)
opt_prob.delVarGroup('a')
opt_prob.addVar('x', 'c', value=1.0, lower=0.0, upper=10)
opt_prob.addVarGroup('y', 2, 'c', value=1.0, lower=0.0, upper=10)
opt_prob.delVarGroup('y')
opt_prob.addVarGroup('z', 1, 'c', value=1.0, lower=0.0, upper=10)
opt_prob.addVarGroup('b', 5, 'c', value=3.0, lower=0.0, upper=10)
opt_prob.delVarGroup('b')
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
opt_prob.addCon('g2', 'i')
print opt_prob

# Instantiate Optimizer (PSQP) & Solve Problem
slsqp = SLSQP()
slsqp(opt_prob)
Пример #8
0
    g = g1 + g2 + g3
    fail = 0
    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
Пример #9
0
def optimize_twist(**k):

    omega = k['omega']
    omega_lower = k['omega_lower']
    omega_upper = k['omega_upper']
    twist0 = k['twist0']
    twist0_lower = k['twist0_lower']
    twist0_upper = k['twist0_upper']
    n_elements = k['n_elements']
    dtwist = k['dtwist']
    dtwist_lower = k['dtwist_lower']
    dtwist_upper = k['dtwist_upper']

    opt_prob_fc = Optimization('Rotor in Hover w/ Fixed Chord',
                               objfun_optimize_twist)
    opt_prob_fc.addVar('omega',
                       'c',
                       value=omega,
                       lower=omega_lower,
                       upper=omega_upper)
    opt_prob_fc.addVar('twist0',
                       'c',
                       value=twist0,
                       lower=twist0_lower,
                       upper=twist0_upper)
    opt_prob_fc.addVarGroup('dtwist',
                            n_elements - 1,
                            'c',
                            value=dtwist,
                            lower=dtwist_lower,
                            upper=dtwist_upper)
    opt_prob_fc.addObj('f')
    opt_prob_fc.addCon('thrust', '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']
    chord = k['chord']
    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 twist with a constant chord
    slsqp2 = SLSQP()
    slsqp2.setOption('IPRINT', 1)
    slsqp2.setOption('MAXIT', 200)
    slsqp2.setOption('ACC', 1e-7)
    fstr, xstr, inform = slsqp2(opt_prob_fc,
                                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,
                                tip_loss=tip_loss,
                                mach_corr=mach_corr,
                                omega=omega,
                                chord=chord,
                                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
Пример #10
0
import numpy as np


def objfun(x, **kwargs):
    W = kwargs['W']
    a = kwargs['a']
    f = a * W.dot(x).dot(x)
    g = [x.sum() - 1]
    fail = 0
    return f, g, fail


opt_prob = Optimization('test problem', objfun)
opt_prob.addVarGroup('x',
                     3,
                     'c',
                     lower=np.zeros(3),
                     upper=np.ones(3),
                     value=[1, 0, 0])
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
print opt_prob

W = np.eye(3)

# Instantiate Optimizer (SLSQP) & Solve Problem
slsqp = SLSQP()
slsqp.setOption('IPRINT', -1)
slsqp(opt_prob, sens_type='FD', W=W, a=10)
print opt_prob.solution(0)
Пример #11
0
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])
    fail = 0

    return -sum([
        x[i] * sum([(1 + len(reachable_sets[i][u])) * y[i][u] - 0.5 * sum([
            len(set(reachable_sets[i][u]) & set(reachable_sets[i][v])) *
            y[i][u] * y[i][v] for v in users if v != u
        ]) for u in users]) for i in items
    ]), g, fail
    #return -np.dot(x,(((1+reachable_sets_len)*y).sum(axis=1) - 0.5*(y*((y[:,:,None]*intersections).sum(axis=2))).sum(axis=1)))


# Initialize problem
opt_prob = Optimization('Algorithm A: Real-valued Relaxation',
                        objective,
                        use_groups=True)
opt_prob.addVarGroup('x', len(x), 'c', lower=0.0, upper=1.0, value=0.5)
opt_prob.addVarGroup('y',
                     len(y.flatten()),
                     'c',
                     lower=0.0,
                     upper=1.0,
                     value=0.5)
opt_prob.addObj('f')
opt_prob.addCon('g0', 'e')
#opt_prob.addConGroup('g1',len(users),'i')
print(opt_prob)

# Instantiate Optimizer (SLSQP) & Solve Problem
slsqp = SLSQP()
slsqp.setOption('IPRINT', -1)
slsqp(opt_prob, sens_type='FD')
Пример #13
0
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()
Пример #14
0
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)