def _reinitialize(self, solver=None, optOptions=None):
try:
import pyoptsparse
except ImportError:
err_msg = (
"It appears you do not have pyOptSparse installed. " +
"Please refer to https://pyoptsparse.readthedocs.io/ for " +
"guidance on how to properly install the module.")
self.logger.error(err_msg, stack_info=True)
raise ImportError(err_msg)
self.optProb = pyoptsparse.Optimization(self.model,
self.objective_func)
self.optProb = self.model.add_var_group(self.optProb)
self.optProb = self.model.add_con_group(self.optProb)
self.optProb.addObj("obj")
if solver is not None:
self.solver = solver
print("Setting up optimization with user's choice of solver: ",
self.solver)
else:
self.solver = "SLSQP"
print("Setting up optimization with default solver: SLSQP.")
if optOptions is not None:
self.optOptions = optOptions
else:
self.optOptions = {"Major feasibility tolerance": 1e-1}
exec("self.opt = pyoptsparse." + self.solver +
"(optOptions=self.optOptions)")
def init_problem(self, n):
print(f"Solving Brachistochrone problem with n = {n}...")
self.n = n
self.x_arr = np.linspace(0, 1, n) # fixed
y_inner = np.linspace(1 - 1 / n, 1 / n,
n - 2) # initial guess of (inner) values
# Optimal/final y points
self.y_arr = np.zeros(n)
self.y_arr[0] = 1.0
# Optimization problem
opt_prob: pyop.Optimization = pyop.Optimization(
'brachistochrone', self.objfunc)
# Design variables
opt_prob.addVarGroup('y', nVars=n-2, type='c', value=y_inner, \
lower=None, upper=None)
# Assign the key value for the objective function
opt_prob.addObj('obj')
# Optimizer
optimizer = pyop.SNOPT()
# optimizer.setOption('iPrint',0)
path = '/home/seth/school/optimization/output/'
# optimizer.setOption('Print file', path+f'SNOPT_print-{n}.out')
# optimizer.setOption('Summary file', path+f'SNOPT_summary-{n}.out')
return opt_prob, optimizer
def init_problem(self):
# Optimization problem
self.opt_prob: pyop.Optimization = pyop.Optimization(
'trusty', self.objfunc)
# Design variables
self.opt_prob.addVarGroup('areas', nVars=10, type='c', value=self.areas, \
lower=0.1, upper=None)
# Constraints
# yield_compression, yield_tension, area_min
stress_yield = np.array([25e3] * 10)
stress_yield[8] = 75e3
self.opt_prob.addConGroup('stress_arr',
nCon=10,
lower=-stress_yield,
upper=stress_yield)
# Assign the key value for the objective function
self.opt_prob.addObj('mass')
self.optimizer = pyop.SNOPT()
self.optimizer.setOption('iPrint', 0)
path = '/home/seth/school/optimization/output/'
self.optimizer.setOption('Print file', path + f'SNOPT_print.out')
self.optimizer.setOption('Summary file', path + f'SNOPT_summary.out')
def optimize_farmcost(*args):
y0 = np.array([9, 10])
funcs, _ = obj_farmcost({"y": y0})
print(f'initial COE: {funcs["coe"]}')
# starting point and bounds
# objective
opt_prob: pyop.Optimization = pyop.Optimization('coe', obj_farmcost)
# linear constraint
# the constraint y3 > y2 can be formulated as a linear constraint.
opt_prob.addVarGroup('y', nVars=2, value=y0, lower=0, upper=10)
opt_prob.addConGroup('y3y2', nCon=1, lower=1e-5)
opt_prob.addObj('coe')
optimizer = pyop.SNOPT()
# deterministic optimization
sol: pyop.pyOpt_solution.Solution = optimizer(opt_prob, sens='FD')
print(f'{sol.fStar.item() = }')
print(f'{sol.xStar["y"] = }')
obj_farmcost(sol.xStar, plotit=False)
#Equality Constraints
funcs['eq_con'] = equalityConstraints(t0, tf, p)
#Inequality Constraints
funcs['ineq_con'] = inequalityConstraints(t_span, p)
return funcs, False
if __name__ == "__main__":
'''----------- Setting up the problem -----------'''
p = np.ones(12) * 1e-4
optProb = pyoptsparse.Optimization('Differential_Flatness', objective)
optProb.addVarGroup('xvars', 12, 'c', lower=None, upper=None, value=p)
eq_bnd = [0.0, 0.0, 0.0, 2.0, 10.0, 0.0, 0.0, 1.0]
optProb.addConGroup('eq_con', 8, lower=eq_bnd, upper=eq_bnd)
if use_gamma:
optProb.addConGroup(
'ineq_con', 400, lower=0.0, upper=None
) # I can get an answer but the constraints are violated and it runs into numerical difficulties
else:
optProb.addConGroup('ineq_con', 200, lower=0.0, upper=None)
optProb.addObj('obj')
opt = pyoptsparse.SNOPT()
sol = opt(optProb, sens='CS', storeHistory='constrained.txt')
data = {
import pyoptsparse
def objfunc(xdict):
x = xdict['xvars']
funcs = {}
funcs['obj'] = -x[0] * x[1] * x[2]
conval = [0] * 2
conval[0] = x[0] + 2. * x[1] + 2. * x[2] - 72.0
conval[1] = -x[0] - 2. * x[1] - 2. * x[2]
funcs['con'] = conval
fail = False
return funcs, fail
optProb = pyoptsparse.Optimization('TP037', objfunc)
optProb.addVarGroup('xvars',
3,
'c',
lower=[0, 0, 0],
upper=[42, 42, 42],
value=10)
optProb.addConGroup('con', 2, lower=None, upper=0.0)
optProb.addObj('obj')
print(optProb)
opt = pyoptsparse.SNOPT()
sol = opt(optProb, sens='FD')
print(sol)
def optimize_pyoptsparse(self, solver, sens, options, callback=None):
"""Solve the problem with pyoptsparse."""
def objfunc_builder():
"""Builds an objective function with a name chosen at run-time."""
def objfunc(xdictInside):
"""Give the objective and constraints in pyoptsparse format."""
funcs = dict()
x = xdictInside['vars'] # extract the variables as a 1D array
funcs[self.objective_name] = self.objective(x)
# add the constraints to the funcs dictionary, one key per group
n_nonlin_constr_per_group = self.n_nonlin_constr_per_group[1:]
for ind, numConstr in enumerate(n_nonlin_constr_per_group):
if ind in self.nonlin_constraint_names:
key = self.nonlin_constraint_names[ind]
else:
key = 'constraint_group{0:d}'.format(ind)
funcs[key] = np.array(self.nonlin_constr[ind](x), ndmin=1)
obj_fail = self.obj_failure(x)
constr_fail_list = [f(x) for f in self.nonlin_constr_fail]
fail = any([constr_fail_list, obj_fail])
return funcs, fail
objfunc.__name__ = self.objective_name
return objfunc
if sens in (None, 'provided'):
def sens(xdict, funcs):
"""Specify objective/constraint gradients in pyoptparse format."""
func_sens = dict()
x = xdict['vars'] # extract the design variables as a 1D array
func_sens[self.objective_name,
'vars'] = np.array(self.gradient(x), ndmin=1)
# add the constraints to the funcs dictionary, one key per group
n_nonlin_constr_per_group = self.n_nonlin_constr_per_group[1:]
for ind, numConstr in enumerate(n_nonlin_constr_per_group):
if ind in self.nonlin_constraint_names:
key = self.nonlin_constraint_names[ind]
else:
key = 'constraint_group{0:d}'.format(ind)
func_sens[key, 'vars'] = np.array(self.nonlin_jac[ind](x),
ndmin=2)
obj_grad_fail = self.grad_failure(x)
constr_jac_fail_list = [f(x) for f in self.nonlin_jac_fail]
fail = any([constr_jac_fail_list, obj_grad_fail])
return func_sens, fail
# Warn the user if they tried to use a callback function
if callback is not None:
raise ValueError('pyoptsparse does not support callbacks.')
# Create an Optimization instance and add the objective function
objfunc = objfunc_builder()
opt_prob = pyoptsparse.Optimization(self.name, objfunc)
opt_prob.addObj(self.objective_name)
# Add the design variables
opt_prob.addVarGroup('vars',
self.nvar,
lower=self.var_bounds[:, 0],
upper=self.var_bounds[:, 1],
value=self.var_init)
## Add the constraints
# Add the nonlinear constraints
n_nonlin_constr_per_group = self.n_nonlin_constr_per_group[1:]
for ind, numConstr in enumerate(n_nonlin_constr_per_group):
if ind in self.nonlin_constraint_names:
constraint_name = self.nonlin_constraint_names[ind]
else:
constraint_name = 'constraint_group{0:d}'.format(ind)
opt_prob.addConGroup(constraint_name,
numConstr,
lower=self.nonlin_bounds_per_group[ind][:, 0],
upper=self.nonlin_bounds_per_group[ind][:, 1])
# Add the linear constraints
opt_prob.addConGroup('Linear Constraints',
self.n_lin_constr,
lower=self.lin_bounds[:, 0],
upper=self.lin_bounds[:, 1],
linear=True,
wrt='vars',
jac={'vars': self.lin_mat})
# Solve the optimization problem
print(opt_prob)
opt = eval('pyoptsparse.' + solver.lstrip('pyoptsparse:') + '()')
sol = opt(opt_prob, sens=sens)
print(sol)
# Extract the optimized parameter vector and objective value
xStar = [None] * self.nvar
for i in range(self.nvar):
xStar[i] = sol.variables['vars'][i].value
fStar = sol.objectives[self.objective_name].value
return (xStar, fStar)
def objfunc(xdict):
x = xdict['xvars']
funcs = {}
funcs['obj'] = -x[0] * x[1] * x[2]
conval = [0] * 2
conval[0] = x[0] + 2. * x[1] + 2. * x[2] - 72.0
conval[1] = -x[0] - 2. * x[1] - 2. * x[2]
funcs['con'] = conval
fail = False
return funcs, fail
optProb: pyop.Optimization = pyop.Optimization('TP037', objfunc)
# Design variables - can be created individually or as a group
optProb.addVarGroup('xvars',
nVars=3,
type='c',
lower=[0, 0, 0],
upper=[42, 42, 42],
value=10)
# Constraints - also individually or group
optProb.addConGroup('con', nCon=2, lower=None, upper=0.0)
optProb.addObj('obj')
print(optProb)
min mu_CD(twist_cp, rv) + 2 * sigma_CD(twist_cp, rv)
twist_cp
subject to mu_CL = 0.5
"""
uq_systemsize = 2
ndv = 5
UQObj = UQOASExample1Opt(uq_systemsize)
collocation_obj = StochasticCollocation(5, "Normal")
collocation_con = collocation_obj
collocation_grad_obj = StochasticCollocation(5,
"Normal",
QoI_dimensions=ndv)
collocation_grad_con = collocation_grad_obj
optProb = pyoptsparse.Optimization('UQ_OASExample1', objfunc)
optProb.addVarGroup('xvars', ndv, 'c', lower=-10., upper=15.)
optProb.addConGroup('con', 1, lower=0.5, upper=0.5)
optProb.addObj('obj')
opt = pyoptsparse.SNOPT(optOptions={'Major feasibility tolerance': 1e-10})
sol = opt(optProb, sens=sens)
# sol = opt(optProb, sens='FD')
# Error Calculation
full_integration_val = 0.03428059998452251
reduced_fval = sol.fStar
err = abs(full_integration_val - reduced_fval)
rel_err = abs((full_integration_val - reduced_fval) / full_integration_val)
print sol
print "integration val = ", sol.fStar
print "error val = ", err
start_solar = 1.0
start_battery_mwh = 100.0
start_battery_mw = 100.0
x = {}
x["electrolyzer_size_mw"] = start_electrolyzer
x["wind_capacity_mw"] = start_wind
x["solar_capacity_mw"] = start_solar
x["battery_storage_mwh"] = start_battery_mwh
x["battery_storage_mw"] = start_battery_mw
funcs, _ = objective_function(x)
start_lcoh = funcs["h_lcoe"] * obj_scale
print("start_lcoh: ", start_lcoh)
optProb = pyoptsparse.Optimization("optimize_sizing",
objective_function)
optProb.addVar("electrolyzer_size_mw",
type="c",
lower=1,
upper=250,
value=start_electrolyzer)
optProb.addVar("wind_capacity_mw",
type="c",
lower=1,
upper=1000,
value=start_wind)
optProb.addVar("solar_capacity_mw",
type="c",
lower=1,
upper=500,
value=start_solar)
def init_problem(self):
px = np.zeros(6) + 1e-4
py = np.zeros(6) + 1e-4
self.n = 100
self.t = np.linspace(0, 15, self.n)
self.tpos_exp = self.t**np.arange(6).reshape(
6, 1) # exponents for trajectory equation
self.tvel_exp = self.t**np.array([0, 0, 1, 2, 3, 4]).reshape(
6, 1) # exponents for veloc terms
self.tacc_exp = self.t**np.array([0, 0, 0, 1, 2, 3]).reshape(
6, 1) # exponents for accel terms
self.tjerk_exp = self.t**np.array([0, 0, 0, 0, 1, 2]).reshape(
6, 1) # exponents for each jerk term
self.cvel = np.arange(
6, dtype=np.float64) # Constant mulipliers for each velocity term
self.cacc = np.array(
[0, 0, 2, 6, 12, 20],
dtype=np.float64) # Constant mulipliers for each acceleration term
self.cjerk = np.array(
[0, 0, 0, 6, 24, 60],
dtype=np.float64) # Constant multipliers for each jerk term
# Optimization problem
opt_prob: pyop.Optimization = pyop.Optimization(
'differential_flat', self.objfunc)
# Design variables
opt_prob.addVarGroup('px',
nVars=6,
type='c',
value=px,
lower=None,
upper=None)
opt_prob.addVarGroup('py',
nVars=6,
type='c',
value=py,
lower=None,
upper=None)
x0, y0, xf, yf = [0., 0., 10., 0.]
vx0, vy0, vxf, vyf = [0., 2., 0., 1.]
self.L = 1.5 # length of car
gam_max = np.pi / 4
self.vmax_square = 10**2 # vmax = 10 m/s
self.amax_square = 2**2 # amax = 2 m/s**2
#### CONSTRAINTS ####
# start and finish constraints
opt_prob.addConGroup('initial pos',
nCon=2,
lower=[x0, y0],
upper=[x0, y0])
opt_prob.addConGroup('initial vel',
nCon=2,
lower=[vx0, vy0],
upper=[vx0, vy0])
opt_prob.addConGroup('final pos',
nCon=2,
lower=[xf, yf],
upper=[xf, yf])
opt_prob.addConGroup('final vel',
nCon=2,
lower=[vxf, vyf],
upper=[vxf, vyf])
# constraints over entire trajectory
opt_prob.addConGroup('v', nCon=self.n, lower=0, upper=self.vmax_square)
opt_prob.addConGroup('a', nCon=self.n, lower=0, upper=self.amax_square)
# opt_prob.addConGroup('gam_max', nCon=self.n, lower=-gam_max, upper=gam_max)
opt_prob.addConGroup('gam_plus', nCon=self.n, lower=0, upper=None)
opt_prob.addConGroup('gam_minus', nCon=self.n, lower=0, upper=None)
# Assign the key value for the objective function
opt_prob.addObj('obj-min-jerk')
# Optimizer
optimizer = pyop.SNOPT()
# optimizer.setOption('iPrint',0)
# optimizer.setOption('iSumm', 0)
# path = '/home/seth/school/optimization/output/'
# optimizer.setOption('Print file', path+f'SNOPT_print-{n}.out')
# optimizer.setOption('Summary file', path+f'SNOPT_summary-{n}.out')
return opt_prob, optimizer
# Get some information on the total number of constraints
n_thickness_intersects = UQObj.QoI.p[
'oas_scaneagle.AS_point_0.wing_perf.thickness_intersects'].size
n_CM = 3
n_constraints = 1 + n_thickness_intersects + 1 + n_CM + 3
# Create the Monte Carlo object based on the dominant directions
nsample = 1000
mc_obj = MonteCarlo(nsample,
UQObj.jdist,
UQObj.QoI_dict,
include_derivs=True)
mc_obj.getSamples(UQObj.jdist, include_derivs=True)
optProb = pyoptsparse.Optimization('UQ_OASScanEagle', objfunc_uq)
n_twist_cp = UQObj.QoI.input_dict['n_twist_cp']
n_thickness_cp = UQObj.QoI.input_dict['n_thickness_cp']
optProb.addVarGroup('twist_cp',
n_twist_cp,
'c',
lower=-5.,
upper=10,
value=init_twist_cp)
optProb.addVarGroup('thickness_cp',
n_thickness_cp,
'c',
lower=0.001,
upper=0.01,
scale=1.e3,
value=init_thickness_cp)
def __init__(self):
# Plotting histories
p0 = np.zeros(6) + 1e-4
self.n = 100
self.t = np.linspace(0, 15, self.n)
self.tpos_exp = self.t**np.arange(6).reshape(
6, 1) # exponents for trajectory equation
self.tvel_exp = self.t**np.array([0, 0, 1, 2, 3, 4]).reshape(
6, 1) # exponents for veloc terms
self.tacc_exp = self.t**np.array([0, 0, 0, 1, 2, 3]).reshape(
6, 1) # exponents for accel terms
self.tjerk_exp = self.t**np.array([0, 0, 0, 0, 1, 2]).reshape(
6, 1) # exponents for each jerk term
self.cvel = np.arange(
6, dtype=np.float64) # Constant mulipliers for each velocity term
self.cacc = np.array(
[0, 0, 2, 6, 12, 20],
dtype=np.float64) # Constant mulipliers for each acceleration term
self.cjerk = np.array(
[0, 0, 0, 6, 24, 60],
dtype=np.float64) # Constant multipliers for each jerk term
# Optimization problem
opt_prob: pyop.Optimization = pyop.Optimization(
'differential_flat_quad', self.objfunc)
# Design variables
opt_prob.addVarGroup('px',
nVars=6,
type='c',
value=p0,
lower=None,
upper=None)
opt_prob.addVarGroup('py',
nVars=6,
type='c',
value=p0,
lower=None,
upper=None)
opt_prob.addVarGroup('pz',
nVars=6,
type='c',
value=p0,
lower=None,
upper=None)
opt_prob.addVarGroup('ps',
nVars=6,
type='c',
value=p0,
lower=None,
upper=None)
# ENU
# [ x, y, z, psi ]
pos0 = np.array([0., 0., 0., 0.])
posf = np.array([0., 10., 10., 0.])
vel0 = np.array([0., 2., 2., 0.])
velf = np.array([0., 2., 0., 0.])
# x0, y0, z0, psi0 = [0., 0., 0., 0.]
# xf, yf, zf, psif = [0., 10., 10., 0.]
# vx0, vy0, vz0, w0 = [0., 2., 2., 0.]
# vxf, vyf, vzf, wf = [0., 2., 0., 0.]
self.L = 1.5 # length of car
gam_max = np.pi / 4
self.vmax_square = 10**2 # vmax = 10 m/s
self.amax_square = 2**2 # amax = 2 m/s**2
#### CONSTRAINTS ####
# start and finish constraints
opt_prob.addConGroup('initial pos', nCon=4, lower=pos0, upper=pos0)
opt_prob.addConGroup('initial vel', nCon=4, lower=vel0, upper=vel0)
opt_prob.addConGroup('final pos', nCon=4, lower=posf, upper=posf)
opt_prob.addConGroup('final vel', nCon=4, lower=velf, upper=velf)
# constraints over entire trajectory
# opt_prob.addConGroup('v', nCon=self.n, lower=0, upper=self.vmax_square)
# opt_prob.addConGroup('a', nCon=self.n, lower=0, upper=self.amax_square)
# opt_prob.addConGroup('gam_max', nCon=self.n, lower=-gam_max, upper=gam_max)
# opt_prob.addConGroup('gam_plus', nCon=self.n, lower=0, upper=None)
# opt_prob.addConGroup('gam_minus', nCon=self.n, lower=0, upper=None)
# Assign the key value for the objective function
opt_prob.addObj('obj-min-jerk')
# Optimizer
optimizer = pyop.SNOPT()
# optimizer.setOption('iPrint',0)
# optimizer.setOption('iSumm', 0)
path = '/home/seth/school/optimization/output/'
optimizer.setOption('Print file', path + f'SNOPT-hw5.out')
optimizer.setOption('Summary file', path + f'SNOPT-hw5-summary.out')
self.opt_prob: pyop.Optimization = opt_prob
self.optimizer: pyop.SNOPT = optimizer
funcs = {}
funcs["obj"] = AEP_sum / 1e9
fail = False
return funcs, fail
solutions = []
for i in range(len(wd)):
wd_itr = wd[i]
ws_itr = ws[i]
freq_itr = freq[i]
# Setup the optimization problem
optProb = pyoptsparse.Optimization("yaw_opt_wd_" + str(wd_itr),
objective_function)
# Add the design variables to the optimization problem
optProb.addVarGroup("yaw", nturbs, "c", lower=0.0, upper=20.0, value=2.0)
# Add the objective to the optimization problem
optProb.addObj("obj")
# Setup the optimization solver
# Note: pyOptSparse has other solvers available; some may require additional
# licenses/installation. See https://github.com/mdolab/pyoptsparse for
# more information. When ready, they can be invoked by changing 'SLSQP'
# to the solver name, for example: 'opt = pyoptsparse.SNOPT(fi=fi)'.
opt = pyoptsparse.SLSQP()
# Run the optimization with finite-differencing
#### Callback function
def callbackF2(Xi):
temp = 1
global Nfeval, all_functions, max_const_vio
print(solve(Xi))
all_functions.append(solve(Xi))
max = np.max(np.abs(constraintAll(Xi)))
max_const_vio.append(max)
#### Solve
# Optimization Object
optProb = pyopt.Optimization('Truss Problem', objfunc)
# Design Variables
optProb.addVarGroup('xvars',
10,
'c',
lower=[0.1] * 10,
upper=None,
value=[0.1] * 10)
lower = [-25e3] * 10
lower[8] = -75e3
upper = [25e3] * 10
upper[8] = 75e3
# set_trace()
def objective_function(varDict, **kwargs):
# Parse the variable dictionary
yaw = varDict["yaw"]
# Compute the objective function
funcs = {}
funcs["obj"] = -1 * fi.get_farm_power_for_yaw_angle(yaw) / 1e5
fail = False
return funcs, fail
# Setup the optimization problem
optProb = pyoptsparse.Optimization("yaw_opt", objective_function)
# Add the design variables to the optimization problem
optProb.addVarGroup("yaw", 4, "c", lower=0, upper=20, value=2.0)
# Add the objective to the optimization problem
optProb.addObj("obj")
# Setup the optimization solver
# Note: pyOptSparse has other solvers available; some may require additional
# licenses/installation. See https://github.com/mdolab/pyoptsparse for more
# information. When ready, they can be invoked by changing 'SLSQP' to the
# solver name, for example: 'opt = pyoptsparse.SNOPT(fi=fi)'.
opt = pyoptsparse.SLSQP(fi=fi)
# Run the optimization with finite-differencing
def Pyoptsparse_Solve(problem,
solver='SNOPT',
FD='single',
sense_step=1.0E-6,
nonderivative_line_search=False):
""" This converts your SUAVE Nexus problem into a PyOptsparse optimization problem and solves it.
Pyoptsparse has many algorithms, they can be switched out by using the solver input.
Assumptions:
None
Source:
N/A
Inputs:
problem [nexus()]
solver [str]
FD (parallel or single) [str]
sense_step [float]
nonderivative_line_search [bool]
Outputs:
outputs [list]
Properties Used:
None
"""
# Have the optimizer call the wrapper
mywrap = lambda x: PyOpt_Problem(problem, x)
inp = problem.optimization_problem.inputs
obj = problem.optimization_problem.objective
con = problem.optimization_problem.constraints
if FD == 'parallel':
from mpi4py import MPI
comm = MPI.COMM_WORLD
myrank = comm.Get_rank()
# Instantiate the problem and set objective
try:
import pyoptsparse as pyOpt
except:
raise ImportError('No version of pyOptsparse found')
opt_prob = pyOpt.Optimization('SUAVE', mywrap)
for ii in range(len(obj)):
opt_prob.addObj(obj[ii, 0])
# Set inputs
nam = inp[:, 0] # Names
ini = inp[:, 1] # Initials
bnd = inp[:, 2] # Bounds
scl = inp[:, 3] # Scale
typ = inp[:, 4] # Type
# Pull out the constraints and scale them
bnd_constraints = help_fun.scale_const_bnds(con)
scaled_constraints = help_fun.scale_const_values(con, bnd_constraints)
x = ini / scl
for ii in range(0, len(inp)):
lbd = (bnd[ii][0] / scl[ii])
ubd = (bnd[ii][1] / scl[ii])
#if typ[ii] == 'continuous':
vartype = 'c'
#if typ[ii] == 'integer':
#vartype = 'i'
opt_prob.addVar(nam[ii], vartype, lower=lbd, upper=ubd, value=x[ii])
# Setup constraints
for ii in range(0, len(con)):
name = con[ii][0]
edge = scaled_constraints[ii]
if con[ii][1] == '<':
opt_prob.addCon(name, upper=edge)
elif con[ii][1] == '>':
opt_prob.addCon(name, lower=edge)
elif con[ii][1] == '=':
opt_prob.addCon(name, lower=edge, upper=edge)
# Finalize problem statement and run
print(opt_prob)
if solver == 'SNOPT':
opt = pyOpt.SNOPT()
CD_step = (sense_step**2.)**(1. / 3.
) #based on SNOPT Manual Recommendations
opt.setOption('Function precision', sense_step**2.)
opt.setOption('Difference interval', sense_step)
opt.setOption('Central difference interval', CD_step)
elif solver == 'SLSQP':
opt = pyOpt.SLSQP()
elif solver == 'FSQP':
opt = pyOpt.FSQP()
elif solver == 'PSQP':
opt = pyOpt.PSQP()
elif solver == 'NSGA2':
opt = pyOpt.NSGA2(pll_type='POA')
elif solver == 'ALPSO':
#opt = pyOpt.pyALPSO.ALPSO(pll_type='DPM') #this requires DPM, which is a parallel implementation
opt = pyOpt.ALPSO()
elif solver == 'CONMIN':
opt = pyOpt.CONMIN()
elif solver == 'IPOPT':
opt = pyOpt.IPOPT()
elif solver == 'NLPQLP':
opt = pyOpt.NLQPQLP()
elif solver == 'NLPY_AUGLAG':
opt = pyOpt.NLPY_AUGLAG()
if nonderivative_line_search == True:
opt.setOption('Nonderivative linesearch')
if FD == 'parallel':
outputs = opt(opt_prob, sens='FD', sensMode='pgc')
elif solver == 'SNOPT' or solver == 'SLSQP':
outputs = opt(opt_prob, sens='FD', sensStep=sense_step)
else:
outputs = opt(opt_prob)
return outputs
