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_id = variables['dv'][dv_name]['ID']
value = variables['dv'][dv_name]['value']
lower = variables['dv'][dv_name]['lower']
upper = variables['dv'][dv_name]['upper']
size = system(dv_id).size
opt_prob.addVarGroup(dv_name,
size,
value=value,
lower=lower,
upper=upper)
opt_prob.finalizeDesignVariables()
for func_name in variables['func'].keys():
lower = variables['func'][func_name]['lower']
upper = variables['func'][func_name]['upper']
if lower is None and upper is None:
opt_prob.addObj(func_name)
else:
opt_prob.addCon(func_name, lower=lower, upper=upper)
if options is None:
options = {}
opt = Optimizer(optimizer, options=options)
sol = opt(opt_prob, sens=self.sens_func)
print sol
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_id = variables['dv'][dv_name]['ID']
value = variables['dv'][dv_name]['value']
lower = variables['dv'][dv_name]['lower']
upper = variables['dv'][dv_name]['upper']
size = system(dv_id).size
opt_prob.addVarGroup(dv_name, size, value=value,
lower=lower, upper=upper)
opt_prob.finalizeDesignVariables()
for func_name in variables['func'].keys():
lower = variables['func'][func_name]['lower']
upper = variables['func'][func_name]['upper']
if lower is None and upper is None:
opt_prob.addObj(func_name)
else:
opt_prob.addCon(func_name, lower=lower, upper=upper)
if options is None:
options = {}
opt = Optimizer(optimizer, options=options)
sol = opt(opt_prob, sens=self.sens_func)
print sol
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 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 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 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
class TestOptProb(unittest.TestCase):
tol = 1e-12
def objfunc(self, xdict):
"""
This is a simple quadratic test function with linear constraints.
The actual problem doesn't really matter, since we are not testing optimization,
but just optProb. However, we need to initialize and run an optimization
in order to have optimizer-specific fields in optProb populated, such as
jacIndices.
This problem is probably not feasible, but that's okay.
"""
funcs = {}
funcs["obj_0"] = 0
for x in xdict.keys():
funcs["obj_0"] += np.sum(np.power(xdict[x], 2))
for iCon, nc in enumerate(self.nCon):
conName = "con_{}".format(iCon)
funcs[conName] = np.zeros(nc)
for x in xdict.keys():
for j in range(nc):
funcs[conName][j] = (iCon + 1) * np.sum(xdict[x])
return funcs, False
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 test_setDV_getDV(self):
"""
We just test that setDV and getDV work, even with scaling
"""
self.setup_optProb(
nObj=1,
nDV=[4, 8],
nCon=[2, 3],
xScale=[4, 1],
objScale=[0.3],
conScale=[0.1, 8],
offset=[3, 7],
)
# test getDV first
x0 = self.optProb.getDVs()
assert_dict_allclose(x0, self.x0)
# now set, get, and compare
newDV = {"x0": np.arange(4), "x1": np.arange(8)}
self.optProb.setDVs(newDV)
outDV = self.optProb.getDVs()
assert_dict_allclose(newDV, outDV)
def test_setDV_VarGroup(self):
"""
Test that setDV works with a subset of VarGroups
"""
self.setup_optProb(
nObj=1,
nDV=[4, 8],
nCon=[2, 3],
xScale=[4, 1],
objScale=[0.3],
conScale=[0.1, 8],
offset=[3, 7],
)
oldDV = self.optProb.getDVs()
# set values for only one VarGroup
newDV = {"x0": np.arange(4)}
self.optProb.setDVs(newDV)
outDV = self.optProb.getDVs()
# check x0 changed
assert_allclose(newDV["x0"], outDV["x0"])
# check x1 is the same
assert_allclose(oldDV["x1"], outDV["x1"])
def test_mappings(self):
"""
This test checks the various mapping and process helper functions
in pyOpt_optimization. In this function we just set up an optimization problem,
and the actual test is done in `map_check_value`.
"""
nDV = [4, 8, 1]
nCon = [2, 3, 1, 1]
self.setup_optProb(
nObj=1,
nDV=nDV,
nCon=nCon,
xScale=[np.random.rand(i) for i in nDV],
objScale=[0.3],
conScale=[np.random.rand(i) for i in nCon],
offset=[np.random.rand(i) * np.arange(i) for i in nDV],
)
# first test X
x = self.optProb.getDVs()
self.map_check_value("X", x)
# next we check the objective
funcs, _ = self.objfunc(x)
obj_funcs = {}
for key in funcs.keys():
if "obj" in key:
obj_funcs[key] = funcs[key]
self.map_check_value("Obj", obj_funcs)
# lastly we check the constraints
funcs, _ = self.objfunc(x)
con_funcs = {}
for key in funcs.keys():
if "con" in key:
con_funcs[key] = funcs[key]
self.map_check_value("Con", con_funcs)
def map_check_value(self, key, val):
"""
This function checks all the mapping and process functions
in both directions, for a given key = {'X', 'Con', 'Obj'}
and val in dictionary format.
"""
# dictionary of function handles to test
map_funcs = {
"X": [self.optProb._mapXtoOpt, self.optProb._mapXtoUser],
"X_Dict": [self.optProb._mapXtoOpt_Dict, self.optProb._mapXtoUser_Dict],
"Con": [self.optProb._mapContoOpt, self.optProb._mapContoUser],
"Con_Dict": [self.optProb._mapContoOpt_Dict, self.optProb._mapContoUser_Dict],
"Obj": [self.optProb._mapObjtoOpt, self.optProb._mapObjtoUser],
"Obj_Dict": [self.optProb._mapObjtoOpt_Dict, self.optProb._mapObjtoUser_Dict],
}
process_funcs = {
"X": {"vec": self.optProb.processXtoVec, "dict": self.optProb.processXtoDict},
"Con": {"vec": self.optProb.processContoVec, "dict": self.optProb.processContoDict},
"Obj": {"vec": self.optProb.processObjtoVec, "dict": self.optProb.processObjtoDict},
}
def processValue(key, val, output):
"""helper function since some functions have optional arguments that are needed"""
if key == "Con":
return process_funcs[key][output](val, scaled=False, natural=True)
elif key == "Obj":
return process_funcs[key][output](val, scaled=False)
else:
return process_funcs[key][output](val)
# test dict to vec mappings
vec = processValue(key, val, "vec")
dictionary = processValue(key, vec, "dict")
assert_dict_allclose(val, dictionary)
# test mappings using dictionaries
val_opt = map_funcs[key + "_Dict"][0](val)
val_user = map_funcs[key + "_Dict"][1](val_opt)
assert_dict_allclose(val_user, val)
assert_dict_not_allclose(val_user, val_opt)
# test mappings using vectors
val = processValue(key, val, "vec")
val_opt = map_funcs[key][0](val)
val_user = map_funcs[key][1](val_opt)
assert_allclose(val_user, val, atol=self.tol, rtol=self.tol)
assert_not_allclose(val_user, val_opt)
# check that the scaling was actually done correctly
# we only check this for the array version because
# it's much simpler
if key == "X":
scale = np.hstack(self.xScale)
offset = np.hstack(self.offset)
assert_allclose(val_opt, (val_user - offset) * scale)
else:
if key == "Obj":
scale = np.hstack(self.objScale)
else:
scale = np.hstack(self.conScale)
assert_allclose(val_opt, val_user * scale)
def test_finalize(self):
"""
Check that multiple finalize calls don't mess up the optProb
"""
self.setup_optProb(nObj=1, nDV=[4, 8], nCon=[2, 3], xScale=[1.0, 1.0], conScale=[1.0, 1.0], offset=[0, 0])
assert_optProb_size(self.optProb, 1, 12, 5)
self.optProb.addObj("obj2")
assert_optProb_size(self.optProb, 2, 12, 5)
self.optProb.addVar("DV2")
assert_optProb_size(self.optProb, 2, 13, 5)
self.optProb.addCon("CON2")
assert_optProb_size(self.optProb, 2, 13, 6)
if MPI.COMM_WORLD.rank == 0:
print('Mass functions')
pprint(massFuncs)
return funcs
def sens(x, funcs):
funcsSens = {}
FEASolver.evalFunctionsSens(sp, funcsSens)
return funcsSens
# Set up the optimization problem
optProb = Optimization('Mass minimization', obj)
optProb.addObj('2.5gload_mass')
FEASolver.addVariablesPyOpt(optProb)
for i in range(3):
optProb.addCon('%s_ks%d' % (sp.name, i), upper=1.0)
if MPI.COMM_WORLD.rank == 0:
print(optProb)
optProb.printSparsity()
optOptions = {}
opt = OPT('snopt', options=optOptions)
sol = opt(optProb, sens=sens, storeHistory='struct.hst')
# Write the final solution
FEASolver.writeOutputFile('final.f5')
sens = sensfunc
if sens == 'matrix-free':
sens = [objgrad, jprod, jtprod]
# Instantiate Optimization Problem
optProb = Optimization('Rosenbrock function', objfunc)
optProb.addVarGroup('xvars',
2,
'c',
value=[3, -3],
lower=-5.12,
upper=5.12,
scale=[1.0, 1.0])
optProb.finalizeDesignVariables()
if constrained:
optProb.addCon('con', upper=0, scale=1.0)
optProb.addObj('obj')
# Create optimizer
opt = OPT(args.opt, options=optOptions)
if testHist == 'no':
# Just run a normal run
sol = opt(optProb, sens=sens, sensMode=sensMode)
# print(sol.fStar)
print(sol)
else:
# First call just does 10 iterations
if args.opt.lower() == 'snopt':
opt.setOption('Major iterations limit', 10)
solSnopt1 = opt(optProb,
sens=sens,
optFuncs.DVCon = DVCon
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)
optFuncs.DVCon = DVCon
optFuncs.evalFuncs = evalFuncs
optFuncs.gcomm = gcomm
# =================================================================================================
# Task
# =================================================================================================
if task.lower() == 'opt':
optProb = Optimization('opt', optFuncs.aeroFuncs, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj('CMZ', scale=1)
# Add physical constraints
optProb.addCon('TPR', lower=1.46, upper=1.46, scale=1)
optProb.addCon('MFR', lower=1.75, upper=1.75, scale=1)
if gcomm.rank == 0:
print optProb
opt = OPT(args.opt, options=optOptions)
histFile = os.path.join(outputDirectory, '%s_hist.hst' % args.opt)
sol = opt(optProb, sens=optFuncs.aeroFuncsSens, storeHistory=histFile)
if gcomm.rank == 0:
print sol
elif task.lower() == 'run':
optFuncs.run()
optFuncs.DVCon = DVCon
optFuncs.evalFuncs = evalFuncs
optFuncs.gcomm = gcomm
# =============================================================================
# Task
# =============================================================================
if args.task == "opt":
optProb = Optimization("opt", objFun=optFuncs.calcObjFuncValues, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
optProb.addObj("M", scale=1.0)
# Add physical constraints
optProb.addCon("VMS", upper=vms0, scale=1.0)
if gcomm.rank == 0:
print(optProb)
DASolver.runColoring()
opt = OPT(args.opt, options=optOptions)
histFile = "./%s_hist.hst" % args.opt
sol = opt(optProb, sens=optFuncs.calcObjFuncSens, storeHistory=histFile)
if gcomm.rank == 0:
print(sol)
elif args.task == "runPrimal":
optFuncs.runPrimal()
optFuncs.evalFuncs = evalFuncs
optFuncs.gcomm = gcomm
# =============================================================================
# Task
# =============================================================================
if args.task == "opt":
optProb = Optimization("opt", objFun=optFuncs.calcObjFuncValues, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj("CMZ", scale=-1)
# Add physical constraints
optProb.addCon("TPR", lower=TPR_target, upper=TPR_target, scale=1)
optProb.addCon("MFR", lower=MFR_target, upper=MFR_target, scale=1)
if gcomm.rank == 0:
print(optProb)
DASolver.runColoring()
opt = OPT(args.opt, options=optOptions)
histFile = "./%s_hist.hst" % args.opt
sol = opt(optProb, sens=optFuncs.calcObjFuncSens, storeHistory=histFile)
if gcomm.rank == 0:
print(sol)
elif args.task == "runPrimal":
return funcsSens,fail
# =================================================================================================
# Task
# =================================================================================================
if task.lower()=='opt':
optProb = Optimization('opt', aeroFuncs, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj('CMZ', scale=1)
# Add physical constraints
optProb.addCon('TPR',lower=1.112,upper=1.112,scale=1)
optProb.addCon('MFR',lower=1.003,upper=1.003,scale=1)
optProb.addCon('VMS',lower=0,upper=4.828e7,scale=1e-7)
if gcomm.rank == 0:
print(optProb)
opt = OPT(args.opt, options=optOptions)
histFile = os.path.join(outputDirectory, '%s_hist.hst'%args.opt)
sol = opt(optProb, sens=aeroFuncsSens, storeHistory=histFile)
if gcomm.rank == 0:
print(sol)
elif task.lower() == 'run':
optFuncs.run()
if args.sens == "user":
sens = sensfunc
else:
sens = args.sens
# Instantiate Optimization Problem
optProb = Optimization("Rosenbrock function", objfunc)
optProb.addVarGroup("xvars",
2,
"c",
value=[3, -3],
lower=-5.12,
upper=5.12,
scale=[1.0, 1.0])
if args.constrained:
optProb.addCon("con", upper=0, scale=1.0)
optProb.addObj("obj")
# Create optimizer
opt = SLSQP(options=optOptions)
if args.testHotstart:
histName = "opt_hist.hst"
# First call just does 10 iterations
opt.setOption("MAXIT", 10)
sol1 = opt(optProb, sens=sens, storeHistory=histName)
# Now we are allowed to do 50
opt.setOption("MAXIT", 50)
sol2 = opt(optProb, sens=sens, hotStart=histName, storeHistory=histName)
print(sol2.fStar)
class TestLarge(OptTest):
name = "large_sparse"
DVs = {"x", "y", "z"}
objs = {"obj"}
cons = {"con1", "con2", "con3"}
xStar = {"x": 2}
fStar = 10.0
def objfunc(self, xdict):
x = xdict["x"]
y = xdict["y"]
z = xdict["z"]
funcs = {}
funcs["obj"] = x**2 + 2 * np.sum(y**2) + 3 * np.sum(z)
funcs["con1"] = x + 1e-3 * abs(x) ** 2.05
funcs["con2"] = x**4 + np.sum(y) + np.sum(z**2)
funcs["con3"] = x + np.sum(z)
return funcs, False
def sens(self, xdict, funcs):
x = xdict["x"]
y = xdict["y"]
z = xdict["z"]
funcsSens = {
"obj": {
"x": 2 * x,
"y": 4 * y,
"z": 3 * np.ones(2 * self.N),
},
"con1": {
"x": 2.05 * x * (x * x) ** 0.025,
},
"con2": {
"x": 4 * x**3,
"y": np.ones(self.N),
"z": 2 * z,
},
"con3": {
"x": 1.0,
"z": np.ones(2 * self.N),
},
}
return funcsSens, False
def setup_optProb(self, sparse=True):
# set N
if sparse:
self.N = 10000
else:
self.N = 500
# Optimization Object
self.optProb = Optimization("large and sparse", self.objfunc, sens=self.sens)
# Design Variables
self.optProb.addVar("x", lower=-100, upper=150, value=0)
self.optProb.addVarGroup("y", self.N, lower=-10 - np.arange(self.N), upper=np.arange(self.N), value=0)
self.optProb.addVarGroup(
"z", 2 * self.N, upper=np.arange(2 * self.N), lower=-100 - np.arange(2 * self.N), value=0
)
# Constraints
self.optProb.addCon("con1", upper=100, wrt=["x"])
self.optProb.addCon("con2", upper=100)
self.optProb.addCon("con3", lower=4, wrt=["x", "z"])
xJac = np.ones((self.N, 1))
if sparse:
rows_cols = np.array([i for i in range(0, self.N)]).astype(int)
yJac = {"coo": [rows_cols, rows_cols, np.ones(self.N)], "shape": [self.N, self.N]}
else:
yJac = np.eye(self.N)
self.optProb.addConGroup(
"lincon",
self.N,
lower=2 - 3 * np.arange(self.N),
linear=True,
wrt=["x", "y"],
jac={"x": xJac, "y": yJac},
)
self.optProb.addObj("obj")
@parameterized.expand(
[
("SNOPT", True),
("IPOPT", True),
("SNOPT", False),
]
)
def test_opt(self, optName, sparse):
self.optName = optName
self.setup_optProb(sparse=sparse)
sol = self.optimize()
self.assert_solution_allclose(sol, 1e-5, partial_x=True)
def test_dense_workspace_too_small(self):
self.optName = "SNOPT"
self.setup_optProb(sparse=False)
optOptions = {"Total real workspace": 401300} # 500 + 200 * (503 + 1501)
sol = self.optimize(optOptions=optOptions)
# Check that the workspace is too small without overwriting the lengths
self.assert_inform_equal(sol, 84)
turbineX = turbineX/scale
turbineY = turbineY/scale
"""Optimization"""
optProb = Optimization('Wind_Farm_AEP', obj_func_max_damage)
# optProb.addObj('AEP')
optProb.addObj('damage')
optProb.addVarGroup('turbineX', nTurbs, type='c', lower=min(xBounds), upper=max(xBounds), value=turbineX)
optProb.addVarGroup('turbineY', nTurbs, type='c', lower=min(yBounds), upper=max(yBounds), value=turbineY)
num_cons_sep = (nTurbs-1)*nTurbs/2
optProb.addConGroup('sep', num_cons_sep, lower=0., upper=None)
optProb.addConGroup('bound', nTurbs, lower=0., upper=None)
# optProb.addConGroup('damage', nTurbs, lower=None, upper=damage_lim)
optProb.addCon('AEP', lower=None, upper=-aep_lim)
opt = SNOPT()
opt.setOption('Scale option',0)
opt.setOption('Iterations limit',1000000)
opt.setOption('Summary file','%s/summary.out'%folder)
opt.setOption('Major optimality tolerance',1.e-4)
opt.setOption('Major feasibility tolerance',1.e-6)
res = opt(optProb)
x = res.xStar['turbineX']
y = res.xStar['turbineY']
input = {'turbineX':x,'turbineY':y}
# Add objective
optProb.addObj("obj", scale=1e4)
# Add variables from the AeroProblem
for ap in aeroProblems:
ap.addVariablesPyOpt(optProb)
# Add DVGeo variables
DVGeo.addVariablesPyOpt(optProb)
# Add constraints
DVCon.addConstraintsPyOpt(optProb)
for ap in aeroProblems:
optProb.addCon(f"cl_con_{ap.name}",
lower=0.0,
upper=0.0,
scale=1.0,
wrt=[f"alpha_{ap.name}", "shape"])
# 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
if args.opt == "SLSQP":
optOptions = {"IFILE": os.path.join(args.output, "SLSQP.out")}
# Task
# =============================================================================
if args.task == "opt":
optProb = Optimization("opt",
objFun=optFuncs.calcObjFuncValuesMP,
comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj("obj", scale=1)
# Add physical constraints
for i in range(nMultiPoints):
optProb.addCon("mp%d_CL" % i,
lower=CL_target[i],
upper=CL_target[i],
scale=1)
if gcomm.rank == 0:
print(optProb)
DASolver.runColoring()
opt = OPT(args.opt, options=optOptions)
histFile = "./%s_hist.hst" % args.opt
sol = opt(optProb, sens=optFuncs.calcObjFuncSensMP, storeHistory=histFile)
if gcomm.rank == 0:
print(sol)
elif args.task == "runPrimal":
# =============================================================================
# Task
# =============================================================================
if args.task == "opt":
alpha4CLTarget = optFuncs.solveCL(CL_target, "alpha", "CL")
alpha([alpha4CLTarget], None)
optProb = Optimization("opt", objFun=optFuncs.calcObjFuncValues, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj("CL", scale=-1)
# Add physical constraints
optProb.addCon("CD", lower=CD_target, upper=CD_target, scale=1)
if gcomm.rank == 0:
print(optProb)
DASolver.runColoring()
opt = OPT(args.opt, options=optOptions)
histFile = "./%s_hist.hst" % args.opt
sol = opt(optProb, sens=optFuncs.calcObjFuncSens, storeHistory=histFile)
if gcomm.rank == 0:
print(sol)
elif args.task == "runPrimal":
optFuncs.runPrimal()
return funcsSens, fail
# =================================================================================================
# Task
# =================================================================================================
if task.lower() == 'opt':
optProb = Optimization('opt', aeroFuncs, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj('CD', scale=1)
# Add physical constraints
optProb.addCon('CL', lower=CL_star, upper=CL_star, scale=1)
if gcomm.rank == 0:
print optProb
opt = OPT(args.opt, options=optOptions)
histFile = os.path.join(outputDirectory, '%s_hist.hst' % args.opt)
sol = opt(optProb, sens=aeroFuncsSens, storeHistory=histFile)
if gcomm.rank == 0:
print sol
elif task.lower() == 'run':
optFuncs.run()
elif task.lower() == 'plotsensmap':
jac = [[2.0 * x[0], 2.0 * x[1], 2.0 * x[2], 2.0 * x[3]]]
funcsSens["con2"] = {"xvars": jac}
fail = False
return funcsSens, fail
# 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.addCon('con1', lower=25, upper=1e19)
optProb.addCon("con1", lower=25)
# optProb.addCon('con2', lower=40, upper=40)
optProb.addCon("con2", lower=40, upper=40)
# Objective
optProb.addObj("obj")
# Check optimization problem:
print(optProb)
# Optimizer
opt = OPT(args.opt, options=optOptions)
# Solution
sol = opt(optProb, sens=sens)
#rst optprob (beg)
# Create optimization problem
optProb = Optimization('opt', MP.obj, comm=MPI.COMM_WORLD)
# Add objective
optProb.addObj('obj', scale=1e4)
# Add variables from the AeroProblem
ap.addVariablesPyOpt(optProb)
# Add DVGeo variables
DVGeo.addVariablesPyOpt(optProb)
# Add constraints
DVCon.addConstraintsPyOpt(optProb)
optProb.addCon('cl_con_'+ap.name, lower=0.0, upper=0.0, scale=1.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
optOptions = {
'Major iterations limit':200,
'Major step limit':2.0,
'Major feasibility tolerance':1.0e-6,
def optimize(self,
sparse=True,
tol=None,
optOptions={},
storeHistory=False):
# set N
if sparse:
self.N = 50000
else:
self.N = 500
# Optimization Object
optProb = Optimization("large and sparse", self.objfunc)
# Design Variables
optProb.addVar("x", lower=-100, upper=150, value=0)
optProb.addVarGroup("y",
self.N,
lower=-10 - np.arange(self.N),
upper=np.arange(self.N),
value=0)
optProb.addVarGroup("z",
2 * self.N,
upper=np.arange(2 * self.N),
lower=-100 - np.arange(2 * self.N),
value=0)
# Constraints
optProb.addCon("con1", upper=100, wrt=["x"])
optProb.addCon("con2", upper=100)
optProb.addCon("con3", lower=4, wrt=["x", "z"])
xJac = np.ones((self.N, 1))
if sparse:
yJac = scipy.sparse.spdiags(np.ones(self.N), 0, self.N, self.N)
else:
yJac = np.eye(self.N)
optProb.addConGroup(
"lincon",
self.N,
lower=2 - 3 * np.arange(self.N),
linear=True,
wrt=["x", "y"],
jac={
"x": xJac,
"y": yJac
},
)
optProb.addObj("obj")
# Optimizer
try:
opt = SNOPT(options=optOptions)
except Error:
raise unittest.SkipTest("Optimizer not available: SNOPT")
sol = opt(optProb, sens=self.sens)
# Check Solution
if tol is not None:
if opt.version != "7.7.7":
assert_allclose(sol.objectives["obj"].value,
10.0,
atol=tol,
rtol=tol)
else:
assert_allclose(sol.fStar, 10.0, atol=tol, rtol=tol)
assert_allclose(sol.variables["x"][0].value,
2.0,
atol=tol,
rtol=tol)
return sol
# Setup Optimization Problem
optProb = Optimization('Basic Aero-Structural Optimization', MP.obj)
# Add variables
DVGeo.addVariablesPyOpt(optProb)
FEASolver.addVariablesPyOpt(optProb)
cruiseProblems[0].addVariablesPyOpt(optProb)
maneuverProblems[0].addVariablesPyOpt(optProb)
geoVars = DVGeo.getValues().keys()
# Add constraints
DVCon.addConstraintsPyOpt(optProb)
FEASolver.addConstraintsPyOpt(optProb)
optProb.addCon('cruise_lift_con',
lower=0.0,
upper=0.0,
scale=1.0 / Mref,
wrt=['struct', 'alpha_cruise'] + geoVars)
optProb.addCon('maneuver_lift_con',
lower=0.0,
upper=0.0,
scale=1.0 / Mref,
wrt=['struct', 'alpha_maneuver'] + geoVars)
for j in range(3):
optProb.addCon('maneuver_ks%d' % j,
upper=1.0,
wrt=['struct', 'alpha_maneuver'] + geoVars)
# Objective:
optProb.addObj('obj')
jac = [[2.0 * x[0], 2.0 * x[1], 2.0 * x[2], 2.0 * x[3]]]
funcsSens['con2'] = {'xvars': jac}
fail = False
return funcsSens, fail
# 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.addCon('con1', lower=25, upper=1e19)
optProb.addCon('con1', lower=25)
# optProb.addCon('con2', lower=40, upper=40)
optProb.addCon('con2', lower=40, upper=40)
# Objective
optProb.addObj('obj')
# Check optimization problem:
print(optProb)
# Optimizer
opt = OPT(args.opt, options=optOptions)
# Solution
sol = opt(optProb, sens=sens)
# rst optprob (beg)
# Create optimization problem
optProb = Optimization("opt", MP.obj, comm=comm)
# Add objective
optProb.addObj("obj", scale=1e2)
# Add variables from the AeroProblem
ap.addVariablesPyOpt(optProb)
# Add DVGeo variables
DVGeo.addVariablesPyOpt(optProb)
# Add constraints
DVCon.addConstraintsPyOpt(optProb)
optProb.addCon("cl_con_" + ap.name, lower=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
if args.opt == "SLSQP":
optOptions = {"IFILE": os.path.join(args.output, "SLSQP.out")}
elif args.opt == "SNOPT":
optOptions = {
Mach = 0.45
Cl_i = np.array([0.5])
Cl_req = np.asscalar(normalize_y(Cl_i, 0))
x0_t = np.zeros(16)
x0_t[14] = Mach
x0_t = normalize_x(x0_t)
Mach_n = x0_t[0, 14]
low_alpha = None
up_alpha = None
optProb = Optimization('naca4412', objfunc)
optProb.addVarGroup('modes', 14, 'c', lower=None, upper=None, value=.5)
optProb.addVar('alpha', 'c', lower=low_alpha, upper=up_alpha, value=.5)
optProb.addCon('thick_0.1', lower=thickness_constraint[0], upper=None)
optProb.addCon('thick_0.3', lower=thickness_constraint[1], upper=None)
optProb.addCon('thick_0.5', lower=thickness_constraint[2], upper=None)
optProb.addCon('thick_0.7', lower=thickness_constraint[3], upper=None)
optProb.addCon('thick_0.9', lower=thickness_constraint[4], upper=None)
optProb.addCon('Cl', lower=Cl_req, upper=Cl_req)
optProb.addObj('obj')
print(optProb)
#%%
opt = pyoptsparse.SLSQP()
sol = opt(optProb, sens=sens)
print(sol)
#%%
modes_opt = sol.xStar['modes']
# =================================================================================================
# Task
# =================================================================================================
if task.lower() == 'opt':
optProb = Optimization('opt', MP.obj, comm=gcomm)
DVGeo.addVariablesPyOpt(optProb)
DVCon.addConstraintsPyOpt(optProb)
# Add objective
optProb.addObj('obj', scale=1000)
# Add physical constraints
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)
# =====================================================
opt_prob = Optimization('opt', MP.obj, use_groups=True)
# Add Aero Variables
for fc in flowCases:
opt_prob.addVar('alpha_' + fc, value=1.6, lower=0., upper=10., scale=.1)
# Add Geo variables
opt_prob = DVGeo.addVariablesPyOpt(opt_prob)
# Constraints:
for fc in flowCases:
opt_prob.addCon('cl_con_' + fc,
type='i',
lower=0.0,
upper=0.0,
scale=10,
wrt=['geo', 'alpha_' + fc])
# Geometric Constraints
DVCon.addConstraintsPyOpt(opt_prob)
# Add Objective
opt_prob.addObj('cd')
# Check opt problem:
if MPI.COMM_WORLD.rank == 0:
print opt_prob
opt_prob.printSparsity()
# The MP object needs the 'obj' and 'sens' function for each proc set,
