def set_pyoptsparse_opt(optname):
"""For testing, sets the pyoptsparse optimizer using the given optimizer
name. This may be modified based on the value of
OPENMDAO_FORCE_PYOPTSPARSE_OPT. This can be used on systems that have
SNOPT installed to force them to use SLSQP in order to mimic our test
machines on travis and appveyor.
"""
OPT = None
OPTIMIZER = None
force = os.environ.get('OPENMDAO_FORCE_PYOPTSPARSE_OPT')
if force:
optname = force
try:
from pyoptsparse import OPT
try:
OPT(optname)
OPTIMIZER = optname
except:
if optname != 'SLSQP':
try:
OPT('SLSQP')
OPTIMIZER = 'SLSQP'
except:
pass
except:
pass
return OPT, OPTIMIZER
def test_autorefine(self):
# Optimization Object
optProb = Optimization("TP109 Constraint Problem", objfunc)
# Design Variables (Removed infinite bounds for ALPSO)
lower = [0.0, 0.0, -0.55, -0.55, 196, 196, 196, -400, -400]
upper = [2000, 2000, 0.55, 0.55, 252, 252, 252, 800, 800]
value = [0, 0, 0, 0, 0, 0, 0, 0, 0]
optProb.addVarGroup("xvars", 9, lower=lower, upper=upper, value=value)
# Constraints
lower = [0, 0, 0, 0, 0, 0, 0, 0]
upper = [None, None, 0, 0, 0, 0, 0, 0]
if not USE_LINEAR:
lower.extend([0, 0])
upper.extend([None, None])
optProb.addConGroup("con", len(lower), lower=lower, upper=upper)
# And the 2 linear constriants
if USE_LINEAR:
jac = np.zeros((1, 9))
jac[0, 3] = 1.0
jac[0, 2] = -1.0
optProb.addConGroup("lin_con",
1,
lower=-0.55,
upper=0.55,
wrt=["xvars"],
jac={"xvars": jac},
linear=True)
# Objective
optProb.addObj("obj")
# Check optimization problem:
# optProb.printSparsity()
# Global Optimizer: ALPSO
try:
opt1 = OPT("ALPSO")
except Error:
raise unittest.SkipTest("Optimizer not available:", "ALPSO")
# Get first Solution
sol1 = opt1(optProb)
# Now run the previous solution with SNOPT
try:
opt2 = OPT("SNOPT")
except Error:
raise unittest.SkipTest("Optimizer not available:", "SNOPT")
sol2 = opt2(sol1)
# Check Solution
assert_allclose(sol2.objectives["obj"].value,
0.536206927538e04,
atol=1e-2,
rtol=1e-2)
def set_pyoptsparse_opt(optname, fallback=True):
"""
For testing, sets the pyoptsparse optimizer using the given optimizer name.
This may be modified based on the value of
OPENMDAO_FORCE_PYOPTSPARSE_OPT. This can be used on systems that have
SNOPT installed to force them to use SLSQP in order to mimic our test
machines on travis and appveyor.
Parameters
----------
optname : str
Name of pyoptsparse optimizer that is requested by the test.
fallback : bool
If True, fall back to SLSQP if optname can't be found
Returns
-------
object
Pyoptsparse optimizer instance.
str
Pyoptsparse optimizer string
"""
OPT = None
opt = None
OPTIMIZER = None
force = os.environ.get('OPENMDAO_FORCE_PYOPTSPARSE_OPT')
if force:
optname = force
try:
from pyoptsparse import OPT
try:
opt = OPT(optname)
OPTIMIZER = optname
except Exception:
if fallback and optname != 'SLSQP':
try:
opt = OPT('SLSQP')
OPTIMIZER = 'SLSQP'
except Exception:
pass
else:
if fallback and isinstance(opt, Mock):
try:
opt = OPT('SLSQP')
OPTIMIZER = 'SLSQP'
except Exception:
pass
except Exception:
pass
if isinstance(opt, Mock):
OPT = OPTIMIZER = None
if not fallback and OPTIMIZER != optname:
raise unittest.SkipTest("pyoptsparse is not providing %s" % optname)
return OPT, OPTIMIZER
def test_autorefine(self):
# Optimization Object
optProb = Optimization('TP109 Constraint Problem', objfunc)
# Design Variables (Removed infinite bounds for ALPSO)
lower = [0.0, 0.0, -0.55, -0.55, 196, 196, 196, -400, -400]
upper = [2000, 2000, 0.55, 0.55, 252, 252, 252, 800, 800]
value = [0, 0, 0, 0, 0, 0, 0, 0, 0]
optProb.addVarGroup('xvars', 9, lower=lower, upper=upper, value=value)
# Constraints
lower = [0, 0, 0, 0, 0, 0, 0, 0]
upper = [None, None, 0, 0, 0, 0, 0, 0]
if not USE_LINEAR:
lower.extend([0, 0])
upper.extend([None, None])
optProb.addConGroup('con', len(lower), lower=lower, upper=upper)
# And the 2 linear constriants
if USE_LINEAR:
jac = numpy.zeros((1, 9))
jac[0, 3] = 1.0
jac[0, 2] = -1.0
optProb.addConGroup('lin_con',
1,
lower=-.55,
upper=0.55,
wrt=['xvars'],
jac={'xvars': jac},
linear=True)
# Objective
optProb.addObj('obj')
# Check optimization problem:
#optProb.printSparsity()
# Global Optimizer: ALPSO
try:
opt1 = OPT('ALPSO')
except:
raise unittest.SkipTest('Optimizer not available:', 'ALPSO')
# Get first Solution
sol1 = opt1(optProb)
# Now run the previous solution with SNOPT
try:
opt2 = OPT('SNOPT')
except:
raise unittest.SkipTest('Optimizer not available:', 'SNOPT')
sol2 = opt2(sol1)
# Check Solution
self.assertAlmostEqual(sol2.objectives['obj'].value,
0.536206927538e+04,
places=2)
def __call__(self, optimizer, options=None):
""" Run optimization """
system = self._system
variables = self._variables
opt_prob = OptProblem('Optimization', self.obj_func)
for dv_name in variables['dv'].keys():
dv = variables['dv'][dv_name]
dv_id = dv['ID']
value = dv['value']
lower = dv['lower']
upper = dv['upper']
size = system.vec['u'](dv_id).shape[0]
opt_prob.addVarGroup(dv_name, size, value=value,
lower=lower, upper=upper)
opt_prob.finalizeDesignVariables()
for func_name in variables['func'].keys():
func = variables['func'][func_name]
func_id = func['ID']
lower = func['lower']
upper = func['upper']
linear = func['linear']
get_jacs = func['get_jacs']
size = system.vec['u'](func_id).shape[0]
if lower is None and upper is None:
opt_prob.addObj(func_name)
else:
if func['get_jacs'] is None:
opt_prob.addConGroup(func_name, size,
lower=lower, upper=upper)
else:
jacs_var = get_jacs()
dv_names = []
jacs = {}
for dv_var in jacs_var:
dv_id = self._system.get_id(dv_var)
dv_name = self._get_name(dv_id)
dv_names.append(dv_name)
jacs[dv_name] = jacs_var[dv_var]
opt_prob.addConGroup(func_name, size,
wrt=dv_names,
jac=jacs, linear=linear,
lower=lower, upper=upper)
if options is None:
options = {}
opt = Optimizer(optimizer, options=options)
opt.setOption('Iterations limit', int(1e6))
#opt.setOption('Verify level', 3)
sol = opt(opt_prob, sens=self.sens_func, storeHistory='hist.hst')
print sol
def decorator(obj):
import unittest
try:
from pyoptsparse import OPT
except Exception:
msg = "pyoptsparse is not installed."
if not isinstance(obj, type):
@functools.wraps(obj)
def skip_wrapper(*args, **kwargs):
raise unittest.SkipTest(msg)
obj = skip_wrapper
obj.__unittest_skip__ = True
obj.__unittest_skip_why__ = msg
return obj
try:
OPT(optimizer)
except Exception:
msg = "pyoptsparse is not providing %s" % optimizer
if not isinstance(obj, type):
@functools.wraps(obj)
def skip_wrapper(*args, **kwargs):
raise unittest.SkipTest(msg)
obj = skip_wrapper
obj.__unittest_skip__ = True
obj.__unittest_skip_why__ = msg
return obj
def optimize(self, optName, optOptions={}, storeHistory=False, places=5):
# Optimization Object
optProb = Optimization('HS071 Constraint Problem', objfunc)
# Design Variables
x0 = [1.0, 5.0, 5.0, 1.0]
optProb.addVarGroup('xvars', 4, lower=1, upper=5, value=x0)
# Constraints
optProb.addConGroup('con', 2, lower=[25, 40], upper=[None, 40])
# Objective
optProb.addObj('obj')
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except:
raise unittest.SkipTest('Optimizer not available:', optName)
sol = opt(optProb, sens=sens)
# Check Solution
self.assertAlmostEqual(sol.objectives['obj'].value, 17.0140172, places=places)
self.assertAlmostEqual(sol.variables['xvars'][0].value, 1.0, places=places)
self.assertAlmostEqual(sol.variables['xvars'][1].value, 4.743, places=places)
self.assertAlmostEqual(sol.variables['xvars'][2].value, 3.82115, places=places)
self.assertAlmostEqual(sol.variables['xvars'][3].value, 1.37941, places=places)
if hasattr(sol, 'lambdaStar'):
self.assertAlmostEqual(sol.lambdaStar['con'][0], 0.55229366, places=places)
self.assertAlmostEqual(sol.lambdaStar['con'][1], -0.16146857, places=places)
def optimize(self, optName, tol, optOptions={}, storeHistory=False, hotStart=None):
self.nf = 0 # number of function evaluations
self.ng = 0 # number of gradient evaluations
# Optimization Object
optProb = Optimization("HS15 Constraint Problem", self.objfunc)
# Design Variables
lower = [-5.0, -5.0]
upper = [0.5, 5.0]
value = [-2, 1.0]
optProb.addVarGroup("xvars", 2, lower=lower, upper=upper, value=value)
# Constraints
lower = [1.0, 0.0]
upper = [None, None]
optProb.addConGroup("con", 2, lower=lower, upper=upper)
# Objective
optProb.addObj("obj")
# Check optimization problem:
print(optProb)
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except Error:
raise unittest.SkipTest("Optimizer not available:", optName)
# Solution
if storeHistory is not None:
if storeHistory is True:
self.histFileName = "%s_hs015_Hist.hst" % (optName.lower())
elif isinstance(storeHistory, str):
self.histFileName = storeHistory
else:
self.histFileName = None
sol = opt(optProb, sens=self.sens, storeHistory=self.histFileName, hotStart=hotStart)
# Test printing solution to screen
print(sol)
# Check Solution
self.fStar1 = 306.5
self.fStar2 = 360.379767
self.xStar1 = (0.5, 2.0)
self.xStar2 = (-0.79212322, -1.26242985)
dv = sol.getDVs()
sol_xvars = [sol.variables["xvars"][i].value for i in range(2)]
assert_allclose(sol_xvars, dv["xvars"], atol=tol, rtol=tol)
# we check either optimum via try/except
try:
assert_allclose(sol.objectives["obj"].value, self.fStar1, atol=tol, rtol=tol)
assert_allclose(dv["xvars"], self.xStar1, atol=tol, rtol=tol)
except AssertionError:
assert_allclose(sol.objectives["obj"].value, self.fStar2, atol=tol, rtol=tol)
assert_allclose(dv["xvars"], self.xStar2, atol=tol, rtol=tol)
def test_dynamic_simul_coloring_pyoptsparse_slsqp(self):
try:
from pyoptsparse import OPT
except ImportError:
raise unittest.SkipTest("This test requires pyoptsparse.")
try:
OPT('SLSQP')
except:
raise unittest.SkipTest("This test requires pyoptsparse SLSQP.")
p_color = run_opt(pyOptSparseDriver, 'rev', optimizer='SLSQP', print_results=False,
dynamic_simul_derivs=True)
assert_almost_equal(p_color['circle.area'], np.pi, decimal=7)
# run w/o coloring
p = run_opt(pyOptSparseDriver, 'rev', optimizer='SLSQP', print_results=False)
assert_almost_equal(p['circle.area'], np.pi, decimal=7)
# - coloring saves 11 solves per driver iter (11 vs 22)
# - initial solve for linear constraints takes 1 in both cases (only done once)
# - dynamic case does 3 full compute_totals to compute coloring, which adds 22 * 3 solves
# - (total_solves - N) / (solves_per_iter) should be equal between the two cases,
# - where N is 1 for the uncolored case and 22 * 3 + 1 for the dynamic colored case.
self.assertEqual((p.model.linear_solver._solve_count - 1) / 22,
(p_color.model.linear_solver._solve_count - 1 - 22 * 3) / 11)
def test_sparsity_pyoptsparse_slsqp(self):
try:
from pyoptsparse import OPT
except ImportError:
raise unittest.SkipTest("This test requires pyoptsparse.")
try:
OPT('SLSQP')
except:
raise unittest.SkipTest("This test requires pyoptsparse SLSQP.")
# first, run without sparsity
p = run_opt(pyOptSparseDriver, 'fwd', optimizer='SLSQP', print_results=False)
# run with dynamic sparsity
p_dynamic = run_opt(pyOptSparseDriver, 'fwd', dynamic_derivs_sparsity=True,
optimizer='SLSQP', print_results=False)
# run with provided sparsity
p_sparsity = run_opt(pyOptSparseDriver, 'fwd', sparsity=self.sparsity,
optimizer='SLSQP', print_results=False)
assert_almost_equal(p['circle.area'], np.pi, decimal=7)
assert_almost_equal(p_dynamic['circle.area'], np.pi, decimal=7)
assert_almost_equal(p_sparsity['circle.area'], np.pi, decimal=7)
def large_sparse(optimizer="SNOPT", optOptions=None):
opt_options = {} if optOptions is None else optOptions
# Optimization Object
optProb = Optimization("large and sparse", objfunc)
# Design Variables
optProb.addVar("x", lower=-100, upper=150, value=0)
optProb.addVarGroup("y", N, lower=-10 - arange(N), upper=arange(N), value=0)
optProb.addVarGroup("z", 2 * N, upper=arange(2 * N), lower=-100 - arange(2 * N), value=0)
# Constraints
optProb.addCon("con1", upper=100, wrt=["x"])
optProb.addCon("con2", upper=100)
optProb.addCon("con3", lower=4, wrt=["x", "z"])
optProb.addConGroup(
"lincon",
N,
lower=2 - 3 * arange(N),
linear=True,
wrt=["x", "y"],
jac={"x": np.ones((N, 1)), "y": sparse.spdiags(np.ones(N), 0, N, N)},
)
optProb.addObj("obj")
# Optimizer
opt = OPT(optimizer, options=opt_options)
optProb.printSparsity()
return opt, optProb
def optimize(self, optName, tol, optOptions={}, storeHistory=False):
# Optimization Object
optProb = Optimization("large and sparse", objfunc)
# Design Variables
optProb.addVar("x", lower=-100, upper=150, value=0)
optProb.addVarGroup("y", N, lower=-10 - arange(N), upper=arange(N), value=0)
optProb.addVarGroup("z", 2 * N, upper=arange(2 * N), lower=-100 - arange(2 * N), value=0)
# Constraints
optProb.addCon("con1", upper=100, wrt=["x"])
optProb.addCon("con2", upper=100)
optProb.addCon("con3", lower=4, wrt=["x", "z"])
optProb.addConGroup(
"lincon",
N,
lower=2 - 3 * arange(N),
linear=True,
wrt=["x", "y"],
jac={"x": np.ones((N, 1)), "y": sparse.spdiags(np.ones(N), 0, N, N)},
)
optProb.addObj("obj")
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except Error:
raise unittest.SkipTest("Optimizer not available:", optName)
sol = opt(optProb, sens=sens)
# Check Solution
assert_allclose(sol.objectives["obj"].value, 10.0, atol=tol, rtol=tol)
assert_allclose(sol.variables["x"][0].value, 2.0, atol=tol, rtol=tol)
def setup_optProb(self, nObj=1, nDV=[4], nCon=[2], xScale=[1.0], objScale=[1.0], conScale=[1.0], offset=[0.0]):
"""
This function sets up a general optimization problem, with arbitrary
DVs, constraints and objectives.
Arbitrary scaling for the various parameters can also be specified.
"""
self.nObj = nObj
self.nDV = nDV
self.nCon = nCon
self.xScale = xScale
self.objScale = objScale
self.conScale = conScale
self.offset = offset
# Optimization Object
self.optProb = Optimization("Configurable Test Problem", self.objfunc)
self.x0 = {}
# Design Variables
for iDV in range(len(nDV)):
n = nDV[iDV]
lower = np.random.uniform(-5, 2, n)
upper = np.random.uniform(5, 20, n)
x0 = np.random.uniform(lower, upper)
dvName = "x{}".format(iDV)
self.x0[dvName] = x0
self.optProb.addVarGroup(
dvName,
n,
lower=lower,
upper=upper,
value=x0,
scale=xScale[iDV],
offset=offset[iDV],
)
# Constraints
for iCon in range(len(nCon)):
nc = nCon[iCon]
lower = np.random.uniform(-5, 2, nc)
upper = np.random.uniform(5, 6, nc)
self.optProb.addConGroup(
"con_{}".format(iCon),
nc,
lower=lower,
upper=upper,
scale=conScale[iCon],
)
# Objective
for iObj in range(nObj):
self.optProb.addObj("obj_{}".format(iObj), scale=objScale[iObj])
# Finalize
self.optProb.printSparsity()
# run optimization
# we don't care about outputs, but this performs optimizer-specific re-ordering
# of constraints so we need this to test mappings
opt = OPT("slsqp", options={"IFILE": "optProb_SLSQP.out"})
opt(self.optProb, "FD")
def optimize(self, optName, optOptions={}, storeHistory=False, places=5):
# Optimization Object
optProb = Optimization('HS15 Constraint Problem', self.objfunc)
# Design Variables
lower = [-5.0, -5.0]
upper = [0.5, 5.0]
value = [-2, 1.0]
optProb.addVarGroup('xvars', 2, lower=lower, upper=upper, value=value)
# Constraints
lower = [1.0, 0.0]
upper = [None, None]
optProb.addConGroup('con', 2, lower=lower, upper=upper)
# Objective
optProb.addObj('obj')
# Check optimization problem:
# print(optProb)
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except:
raise unittest.SkipTest('Optimizer not available:', optName)
# Solution
if storeHistory:
histFileName = '%s_hs015_Hist.hst' % (optName.lower())
else:
histFileName = None
sol = opt(optProb, sens=self.sens, storeHistory=histFileName)
# Test printing solution to screen
print(sol)
# Check Solution
fobj = sol.objectives['obj'].value
diff = np.min(np.abs([fobj - 306.5, fobj - 360.379767]))
self.assertAlmostEqual(diff, 0.0, places=places)
xstar1 = (0.5, 2.0)
xstar2 = (-0.79212322, -1.26242985)
x1 = sol.variables['xvars'][0].value
x2 = sol.variables['xvars'][1].value
dv = sol.getDVs()
self.assertAlmostEqual(x1, dv['xvars'][0], places=10)
self.assertAlmostEqual(x2, dv['xvars'][1], places=10)
diff = np.min(np.abs([xstar1[0] - x1, xstar2[0] - x1]))
self.assertAlmostEqual(diff, 0.0, places=places)
diff = np.min(np.abs([xstar1[1] - x2, xstar2[1] - x2]))
self.assertAlmostEqual(diff, 0.0, places=places)
def optimize(self, optName, tol, optOptions={}, storeHistory=False, hotStart=None):
self.nf = 0 # number of function evaluations
self.ng = 0 # number of gradient evaluations
# Optimization Object
optProb = Optimization("Rosenbrock Problem", self.objfunc)
n = 4 # Number of design variables
np.random.seed(10)
value = np.random.normal(size=n)
lower = np.ones(n) * -50
upper = np.ones(n) * 50
optProb.addVarGroup("xvars", n, lower=lower, upper=upper, value=value)
# Objective
optProb.addObj("obj")
# Check optimization problem:
print(optProb)
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except Error:
raise unittest.SkipTest("Optimizer not available:", optName)
# Solution
if storeHistory is not None:
if storeHistory is True:
self.histFileName = "%s_Rsbrk_Hist.hst" % (optName.lower())
elif isinstance(storeHistory, str):
self.histFileName = storeHistory
else:
self.histFileName = None
sol = opt(optProb, sens=self.sens, storeHistory=self.histFileName, hotStart=hotStart)
# Test printing solution to screen
print(sol)
# Check Solution
self.fStar1 = 0.0
self.xStar1 = np.ones(n)
dv = sol.getDVs()
sol_xvars = [sol.variables["xvars"][i].value for i in range(n)]
assert_allclose(sol_xvars, dv["xvars"], atol=tol, rtol=tol)
assert_allclose(dv["xvars"], self.xStar1, atol=tol, rtol=tol)
if optName == "SNOPT" and opt.version != "7.7.7":
assert_allclose(sol.objectives["obj"].value, self.fStar1, atol=tol, rtol=tol)
else:
assert_allclose(sol.fStar, self.fStar1, atol=tol, rtol=tol)
def pyopt_truss(truss, optimizer='snopt', options={}):
'''
Take the given problem and optimize it with the given optimizer
from the pyOptSparse library of optimizers.
'''
# Import the optimization problem
from pyoptsparse import Optimization, OPT
class pyOptWrapper:
def __init__(self, truss):
self.truss = truss
def objcon(self, x):
fail, obj, con = self.truss.evalObjCon(x['x'])
funcs = {'objective': obj, 'con': con}
return funcs, fail
def gobjcon(self, x, funcs):
g = np.zeros(x['x'].shape)
A = np.zeros((1, x['x'].shape[0]))
fail = self.truss.evalObjConGradient(x['x'], g, A)
sens = {'objective': {'x': g}, 'con': {'x': A}}
return sens, fail
# Set the design variables
wrap = pyOptWrapper(truss)
prob = Optimization('Truss', wrap.objcon)
# Determine the initial variable values and their lower/upper
# bounds in the design problem
n = len(truss.conn)
x0 = np.zeros(n)
lower = np.zeros(n)
upper = np.zeros(n)
truss.getVarsAndBounds(x0, lower, upper)
# Set the variable bounds and initial values
prob.addVarGroup('x', n, value=x0, lower=lower, upper=upper)
# Set the constraints
prob.addConGroup('con', 1, lower=0.0, upper=0.0)
# Add the objective
prob.addObj('objective')
# Optimize the problem
try:
opt = OPT(optimizer, options=options)
sol = opt(prob, sens=wrap.gobjcon)
except:
opt = None
sol = None
return opt, prob, sol
def test_sparsity_pyoptsparse_slsqp(self):
try:
from pyoptsparse import OPT
except ImportError:
raise unittest.SkipTest("This test requires pyoptsparse.")
try:
OPT('SLSQP')
except:
raise unittest.SkipTest("This test requires pyoptsparse SLSQP.")
sparsity = {
"circle.area": {
"indeps.x": [[], [], [1, 10]],
"indeps.y": [[], [], [1, 10]],
"indeps.r": [[0], [0], [1, 1]]
},
"r_con.g": {
"indeps.x": [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10, 10]],
"indeps.y": [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10, 10]],
"indeps.r": [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [10, 1]]
},
"theta_con.g": {
"indeps.x": [[0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [5, 10]],
"indeps.y": [[0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [5, 10]],
"indeps.r": [[], [], [5, 1]]
},
"delta_theta_con.g": {
"indeps.x": [[0, 0, 1, 1, 2, 2, 3, 3, 4, 4],
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [5, 10]],
"indeps.y": [[0, 0, 1, 1, 2, 2, 3, 3, 4, 4],
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [5, 10]],
"indeps.r": [[], [], [5, 1]]
},
"l_conx.g": {
"indeps.x": [[0], [0], [1, 10]],
"indeps.y": [[], [], [1, 10]],
"indeps.r": [[], [], [1, 1]]
}
}
p_sparsity = run_opt(pyOptSparseDriver,
sparsity=sparsity,
optimizer='SLSQP',
print_results=False)
assert_almost_equal(p_sparsity['circle.area'], np.pi, decimal=7)
# run w/o coloring
p = run_opt(pyOptSparseDriver, optimizer='SLSQP', print_results=False)
assert_almost_equal(p['circle.area'], np.pi, decimal=7)
def optimize(
self,
optName,
tol,
optOptions={},
storeHistory=False,
setDV=None,
xScale=1.0,
objScale=1.0,
conScale=1.0,
offset=0.0,
check_solution=True,
):
# Optimization Object
optProb = Optimization("HS071 Constraint Problem", self.objfunc)
# Design Variables
x0 = [1.0, 5.0, 5.0, 1.0]
optProb.addVarGroup("xvars", 4, lower=1, upper=5, value=x0, scale=xScale, offset=offset)
# Constraints
optProb.addConGroup("con", 2, lower=[25, 40], upper=[None, 40], scale=conScale)
# Objective
optProb.addObj("obj", scale=objScale)
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except Error:
raise unittest.SkipTest("Optimizer not available:", optName)
if isinstance(setDV, str):
optProb.setDVsFromHistory(setDV)
elif isinstance(setDV, dict):
optProb.setDVs(setDV)
outDV = optProb.getDVs()
assert_allclose(setDV["xvars"], outDV["xvars"])
sol = opt(optProb, sens=self.sens, storeHistory=storeHistory)
# Check Solution
if check_solution:
self.fStar = 17.0140172
self.xStar = (1.0, 4.743, 3.82115, 1.37941)
self.lambdaStar = (0.55229366, -0.16146857)
assert_allclose(sol.objectives["obj"].value, self.fStar, atol=tol, rtol=tol)
assert_allclose(sol.xStar["xvars"], self.xStar, atol=tol, rtol=tol)
if hasattr(sol, "lambdaStar"):
assert_allclose(sol.lambdaStar["con"], self.lambdaStar, atol=tol, rtol=tol)
return sol
def optimize(self, optName, tol, optOptions={}):
# Optimization Object
optProb = Optimization("TP109 Constraint Problem", objfunc)
# Design Variables
lower = [0.0, 0.0, -0.55, -0.55, 196, 196, 196, -400, -400]
upper = [None, None, 0.55, 0.55, 252, 252, 252, 800, 800]
value = [0, 0, 0, 0, 0, 0, 0, 0, 0]
optProb.addVarGroup("xvars", 9, lower=lower, upper=upper, value=value)
# Constraints
lower = [0, 0, 0, 0, 0, 0, 0, 0]
upper = [None, None, 0, 0, 0, 0, 0, 0]
if not USE_LINEAR:
lower.extend([0, 0])
upper.extend([None, None])
optProb.addConGroup("con", len(lower), lower=lower, upper=upper)
# And the 2 linear constriants
if USE_LINEAR:
jac = np.zeros((1, 9))
jac[0, 3] = 1.0
jac[0, 2] = -1.0
optProb.addConGroup("lin_con",
1,
lower=-0.55,
upper=0.55,
wrt=["xvars"],
jac={"xvars": jac},
linear=True)
# Objective
optProb.addObj("obj")
# Check optimization problem:
# optProb.printSparsity()
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except Error:
raise unittest.SkipTest("Optimizer not available:", optName)
# Solution
sol = opt(optProb, sens="CS")
# Check Solution
assert_allclose(sol.objectives["obj"].value,
0.536206927538e04,
atol=tol,
rtol=tol)
def optimize(self, optName, optOptions={}, places=2):
# Optimization Object
optProb = Optimization('TP109 Constraint Problem', objfunc)
# Design Variables
lower = [0.0, 0.0, -0.55, -0.55, 196, 196, 196, -400, -400]
upper = [None, None, 0.55, 0.55, 252, 252, 252, 800, 800]
value = [0, 0, 0, 0, 0, 0, 0, 0, 0]
optProb.addVarGroup('xvars', 9, lower=lower, upper=upper, value=value)
# Constraints
lower = [0, 0, 0, 0, 0, 0, 0, 0]
upper = [None, None, 0, 0, 0, 0, 0, 0]
if not USE_LINEAR:
lower.extend([0, 0])
upper.extend([None, None])
optProb.addConGroup('con', len(lower), lower=lower, upper=upper)
# And the 2 linear constriants
if USE_LINEAR:
jac = numpy.zeros((1, 9))
jac[0, 3] = 1.0
jac[0, 2] = -1.0
optProb.addConGroup('lin_con',
1,
lower=-.55,
upper=0.55,
wrt=['xvars'],
jac={'xvars': jac},
linear=True)
# Objective
optProb.addObj('obj')
# Check optimization problem:
#optProb.printSparsity()
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except:
raise unittest.SkipTest('Optimizer not available:', optName)
# Solution
sol = opt(optProb, sens='CS')
# Check Solution
self.assertAlmostEqual(sol.objectives['obj'].value,
0.536206927538e+04,
places=places)
def optimize(self, optName, optOptions={}, storeHistory=False, places=5):
# Optimization Object
optProb = Optimization('large and sparse', objfunc)
# Design Variables
optProb.addVar('x', lower=-100, upper=150, value=0)
optProb.addVarGroup('y',
N,
lower=-10 - arange(N),
upper=arange(N),
value=0)
optProb.addVarGroup('z',
2 * N,
upper=arange(2 * N),
lower=-100 - arange(2 * N),
value=0)
# Constraints
optProb.addCon('con1', upper=100, wrt=['x'])
optProb.addCon('con2', upper=100)
optProb.addCon('con3', lower=4, wrt=['x', 'z'])
optProb.addConGroup('lincon',
N,
lower=2 - 3 * arange(N),
linear=True,
wrt=['x', 'y'],
jac={
'x': numpy.ones((N, 1)),
'y': sparse.spdiags(numpy.ones(N), 0, N, N)
})
optProb.addObj('obj')
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except:
raise unittest.SkipTest('Optimizer not available:', optName)
sol = opt(optProb, sens=sens)
# Check Solution
self.assertAlmostEqual(sol.objectives['obj'].value,
10.0,
places=places)
self.assertAlmostEqual(sol.variables['x'][0].value, 2.0, places=places)
def optimize(self, optName, optOptions={}, storeHistory=False):
# Optimization Object
optProb = Optimization('HS15 Constraint Problem', self.objfunc)
# Design Variables
lower = [-5, -5]
upper = [0.5, 5]
value = [-2, 1]
optProb.addVarGroup('xvars', 2, lower=lower, upper=upper, value=value)
# Constraints
lower = [1, 0]
upper = [None, None]
optProb.addConGroup('con', 2, lower=lower, upper=upper)
# Objective
optProb.addObj('obj')
# Check optimization problem:
# print(optProb)
# Optimizer
try:
opt = OPT(optName, options=optOptions)
except:
raise unittest.SkipTest('Optimizer not available:', optName)
# Solution
if storeHistory:
histFileName = '%s_hs015_Hist.hst' % (optName.lower())
else:
histFileName = None
sol = opt(optProb, sens=self.sens, storeHistory=histFileName)
# Check Solution
self.assertAlmostEqual(sol.objectives['obj'].value, 306.5)
self.assertAlmostEqual(sol.variables['xvars'][0].value, 0.5)
self.assertAlmostEqual(sol.variables['xvars'][1].value, 2.0)
def optimize(self, x0, alg='IPOPT', options={}):
opt = {}
opt.update(options)
def objfun(xdict):
x, fail = self.set_vars(xdict)
funcs= {
'obj': self.obj(x),
'llcon': self.lifting_line_const(x),
"wcon": self.enough_lift_const(x)
}
return funcs, fail
optProb = Optimization('llOpt', objfun)
ub = self.get_vars(self.bounds.ub, dic=True)
lb = self.get_vars(self.bounds.lb, dic=True)
x0 = self.get_vars(x0, dic=True)
optProb.addVar('V', upper=ub['V'], lower=lb['V'], value=x0['V'])
optProb.addVar('b', upper=ub['b'], lower=lb['b'], value=x0['b'])
optProb.addVarGroup('c', self.N_th, upper=ub['c'], lower=lb['c'], value=x0['c'])
optProb.addVarGroup('al', self.N_th, upper=ub['al'], lower=lb['al'], value=x0['al'])
optProb.addVarGroup('A', self.N_A, upper=ub['A'], lower=lb['A'], value=x0['A'])
optProb.addObj('obj')
optProb.addConGroup('llcon', self.N_th, lower=0., upper=0.)
optProb.addCon('wcon', lower=0., upper=0.)
if alg== "IPOPT":
opt = OPT(alg, options=options)
sol = opt(optProb, sens='FD')
else:
raise NotImplementedError(f"No routine for algorithm {alg}")
D = dict(
al = [a.value for a in sol.variables['al']],
c = [a.value for a in sol.variables['c']],
A = [a.value for a in sol.variables['A']],
b = sol.variables['b'][0].value,
V = sol.variables['V'][0].value,
)
x = self.set_vars(D)[0]
return x, sol
def test_dynamic_total_coloring_pyoptsparse_slsqp_auto(self):
try:
from pyoptsparse import OPT
except ImportError:
raise unittest.SkipTest("This test requires pyoptsparse.")
try:
OPT('SLSQP')
except:
raise unittest.SkipTest("This test requires pyoptsparse SLSQP.")
p_color = run_opt(pyOptSparseDriver,
'auto',
optimizer='SLSQP',
print_results=False,
dynamic_total_coloring=True)
assert_almost_equal(p_color['circle.area'], np.pi, decimal=7)
# run w/o coloring
p = run_opt(pyOptSparseDriver,
'auto',
optimizer='SLSQP',
print_results=False)
assert_almost_equal(p['circle.area'], np.pi, decimal=7)
# - coloring saves 16 solves per driver iter (5 vs 21)
# - initial solve for linear constraints takes 21 in both cases (only done once)
# - dynamic case does 3 full compute_totals to compute coloring, which adds 21 * 3 solves
# - (total_solves - N) / (solves_per_iter) should be equal between the two cases,
# - where N is 21 for the uncolored case and 21 * 4 for the dynamic colored case.
self.assertEqual((p.model._solve_count - 21) / 21,
(p_color.model._solve_count - 21 * 4) / 5)
# test __repr__
rep = repr(p_color.driver._coloring_info['coloring'])
self.assertEqual(
rep.replace('L', ''),
'Coloring (direction: fwd, ncolors: 5, shape: (22, 21)')
def large_sparse(optimizer='SNOPT', optOptions=None):
opt_options = {} if optOptions is None else optOptions
# Optimization Object
optProb = Optimization('large and sparse', objfunc)
# Design Variables
optProb.addVar('x', lower=-100, upper=150, value=0)
optProb.addVarGroup('y',
N,
lower=-10 - arange(N),
upper=arange(N),
value=0)
optProb.addVarGroup('z',
2 * N,
upper=arange(2 * N),
lower=-100 - arange(2 * N),
value=0)
# Constraints
optProb.addCon('con1', upper=100, wrt=['x'])
optProb.addCon('con2', upper=100)
optProb.addCon('con3', lower=4, wrt=['x', 'z'])
optProb.addConGroup('lincon',
N,
lower=2 - 3 * arange(N),
linear=True,
wrt=['x', 'y'],
jac={
'x': numpy.ones((N, 1)),
'y': sparse.spdiags(numpy.ones(N), 0, N, N)
})
optProb.addObj('obj')
# Optimizer
opt = OPT(optimizer, options=opt_options)
optProb.printSparsity()
return opt, optProb
def test_snopt_hotstart(self):
self.optName = "SNOPT"
self.setup_optProb()
sol, restartDict = self.optimize(
optOptions={"Return work arrays": True})
# Check Solution
self.assert_solution_allclose(sol, 1e-12)
# Check informs
self.assert_inform_equal(sol)
# Check restartDict
self.assertEqual({"cw", "iw", "rw", "xs", "hs", "pi"},
set(restartDict.keys()))
# Now optimize again, but using the hotstart
self.setup_optProb()
self.nf = 0
self.ng = 0
opt = OPT(self.optName, options={"Start": "Hot", "Verify level": -1})
sol = opt(self.optProb, sens=self.sens, restartDict=restartDict)
# Check Solution
self.assert_solution_allclose(sol, 1e-12)
# Should only take one major iteration
self.assertEqual(self.nf, 1)
self.assertEqual(self.ng, 1)
def optimize(self, x0, alg='IPOPT', options={}):
opt = {}
opt.update(options)
def objfun(xdict):
V = xdict['V']
b = xdict['b']
c = xdict['c']
al = xdict['al']
A, fail = self.ll(V, b, c, al)
funcs= {
'obj':10000. if fail else self.DoverL(V, b, c, al, A)
}
return funcs, fail
optProb = Optimization('llOpt', objfun)
ub = self.get_vars(self.bounds.ub, dic=True)
lb = self.get_vars(self.bounds.lb, dic=True)
x0 = self.get_vars(x0, dic=True)
optProb.addVar('V', upper=ub['V'], lower=lb['V'], value=x0['V'])
optProb.addVar('b', upper=ub['b'], lower=lb['b'], value=x0['b'])
optProb.addVarGroup('c', self.N_th, upper=ub['c'], lower=lb['c'], value=x0['c'])
optProb.addVarGroup('al', self.N_th, upper=ub['al'], lower=lb['al'], value=x0['al'])
optProb.addObj('obj')
if alg== "IPOPT":
opt = OPT(alg, options=options)
sol = opt(optProb, sens='FD')
else:
raise NotImplementedError(f"No routine for algorithm {alg}")
D = dict(
al = [a.value for a in sol.variables['al']],
c = [a.value for a in sol.variables['c']],
b = sol.variables['b'][0].value,
V = sol.variables['V'][0].value
)
x = self.set_vars(D)[0]
return x, sol
from openmdao.test.example_groups import ExampleGroup
from openmdao.test.sellar import SellarDerivativesGrouped
from openmdao.test.util import assert_rel_error
from openmdao.util.record_util import format_iteration_coordinate
from openmdao.recorders.sqlite_recorder import format_version
# check that pyoptsparse is installed
# if it is, try to use SLSQP
OPT = None
OPTIMIZER = None
try:
from pyoptsparse import OPT
try:
OPT('SLSQP')
OPTIMIZER = 'SLSQP'
except:
pass
except:
pass
if OPTIMIZER:
from openmdao.drivers.pyoptsparse_driver import pyOptSparseDriver
def run_problem(problem):
t0 = time.time()
problem.run()
t1 = time.time()
return t0, t1
for i in xrange(nFlowCases):
optProb.addCon('fc%d_CL_con' % i, lower=0.0, upper=0.0, scale=1.0)
if gcomm.rank == 0:
print(optProb)
# The MP object needs the 'obj' and 'sens' function for each proc set,
# the optimization problem and what the objcon function is:
MP.setProcSetObjFunc(optVars[0] + '_mp', aeroFuncsMP)
MP.setProcSetSensFunc(optVars[0] + '_mp', aeroFuncsSensMP)
MP.setObjCon(objCon)
MP.setOptProb(optProb)
optProb.printSparsity()
# Make Instance of Optimizer
opt = OPT(args.opt, options=optOptions)
# Run Optimization
histFile = os.path.join(outputDirectory, '%s_hist.hst' % args.opt)
sol = opt(optProb, MP.sens, storeHistory=histFile)
if gcomm.rank == 0:
print(sol)
elif task.lower() == 'solvecl':
CFDSolver.setOption('usecoloring', False)
xDV0 = DVGeo.getValues()
alpha0 = xDV0['alpha']
for i in range(10):
optFuncs.evalFuncs = evalFuncs
optFuncs.gcomm = gcomm
optFuncs.setMultiPointCondition = setMultiPointCondition
optFuncs.setMultiPointObjFuncs = setMultiPointObjFuncs
optFuncs.setMultiPointObjFuncsSens = setMultiPointObjFuncsSens
# Optimize
DASolver.runColoring()
optProb = Optimization("opt", optFuncs.calcObjFuncValuesMP, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj("CD", scale=1)
# Add physical constraints
optProb.addCon("CL", lower=CL_target, upper=CL_target, scale=1)
optProb.addCon("CMZ", lower=CM_target, upper=CM_target, scale=1)
if gcomm.rank == 0:
print(optProb)
opt = OPT("slsqp", options=optOptions)
histFile = os.path.join("./", "slsqp_hist.hst")
sol = opt(optProb, sens=optFuncs.calcObjFuncSensMP, storeHistory=histFile)
if gcomm.rank == 0:
print(sol)
xDVs = DVGeo.getValues()
if gcomm.rank == 0:
reg_write_dict(xDVs, 1e-6, 1e-8)
def __call__(self, optimizer, options=None):
""" Run optimization """
system = self._system
variables = self._variables
opt_prob = OptProblem('Optimization', self.obj_func)
for dv_name in variables['dv'].keys():
dv = variables['dv'][dv_name]
dv_id = dv['ID']
if dv['value'] is not None:
value = dv['value']
else:
value = system.vec['u'](dv_id)
scale = dv['scale']
lower = dv['lower']
upper = dv['upper']
size = system.vec['u'](dv_id).shape[0]
opt_prob.addVarGroup(dv_name, size, value=value, scale=scale,
lower=lower, upper=upper)
opt_prob.finalizeDesignVariables()
for func_name in variables['func'].keys():
func = variables['func'][func_name]
func_id = func['ID']
lower = func['lower']
upper = func['upper']
linear = func['linear']
get_jacs = func['get_jacs']
sys = func['sys']
size = system.vec['u'](func_id).shape[0]
if lower is None and upper is None:
opt_prob.addObj(func_name)
else:
if get_jacs is not None:
jacs_var = get_jacs()
dv_names = []
jacs = {}
for dv_var in jacs_var:
dv_id = self._system.get_id(dv_var)
dv_name = self._get_name(dv_id)
dv_names.append(dv_name)
jacs[dv_name] = jacs_var[dv_var]
opt_prob.addConGroup(func_name, size,
wrt=dv_names,
jac=jacs, linear=linear,
lower=lower, upper=upper)
elif sys is not None:
dv_names = []
for dv_name in variables['dv'].keys():
dv_id = variables['dv'][dv_name]['ID']
if dv_id in sys.vec['u']:
dv_names.append(dv_name)
opt_prob.addConGroup(func_name, size,
wrt=dv_names,
lower=lower, upper=upper)
else:
opt_prob.addConGroup(func_name, size,
lower=lower, upper=upper)
if options is None:
options = {}
opt = Optimizer(optimizer, options=options)
opt.setOption('Iterations limit', int(1e6))
#opt.setOption('Verify level', 3)
sol = opt(opt_prob, sens=self.sens_func, storeHistory='hist.hst')
print sol
try:
exit_status = sol.optInform['value']
self.exit_flag = 1
if exit_status > 2: # bad
self.exit_flag = 0
except KeyError: #nothing is here, so something bad happened!
self.exit_flag = 0
optProb.addCon("cl_con_" + ap.name, lower=0.0, upper=0.0, scale=10.0)
# The MP object needs the 'obj' and 'sens' function for each proc set,
# the optimization problem and what the objcon function is:
MP.setProcSetObjFunc("cruise", cruiseFuncs)
MP.setProcSetSensFunc("cruise", cruiseFuncsSens)
MP.setObjCon(objCon)
MP.setOptProb(optProb)
optProb.printSparsity()
# rst optprob (end)
# rst optimizer
# Set up optimizer
optimizer = "SLSQP"
if optimizer == "SLSQP":
optOptions = {"IFILE": os.path.join(outputDirectory, "SLSQP.out")}
opt = OPT("slsqp", options=optOptions)
elif optimizer == "SNOPT":
optOptions = {
"Major feasibility tolerance": 1e-4,
"Major optimality tolerance": 1e-4,
"Difference interval": 1e-3,
"Hessian full memory": None,
"Function precision": 1e-8,
"Print file": os.path.join(outputDirectory, "SNOPT_print.out"),
"Summary file": os.path.join(outputDirectory, "SNOPT_summary.out"),
'Major iterations limit': 1000,
}
opt = OPT("snopt", options=optOptions)
# Run Optimization
sol = opt(optProb, MP.sens, storeHistory=os.path.join(outputDirectory, "opt.hst"))
