def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
store_hst=False,
hot_start=False,
disp_opts=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity setp size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the
objective function call.
Documentation last updated: February. 2, 2011 - Ruben E. Perez
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError(
"pyKSOPT - Current implementation only allows single level"
" parallelization, either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyKSOPT: Parallel objective Function Analysis '
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['IFILE'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step)
# ======================================================================
# KSOPT - Objective/Constraint Values Function
# ======================================================================
def ksobj(nv, no, nc, x, f, g):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function
fail = 0
ff = []
gg = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[ff, gg, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[ff, gg, fail] = Bcast([ff, gg, fail], root=0)
elif not self.h_start:
[ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(ff, 'obj')
log_file.write(gg, 'con')
log_file.write(fail, 'fail')
# Objective Assignment
if isinstance(ff, float):
ff = [ff]
for i in range(len(opt_problem.objectives.keys())):
if isinstance(ff[i], complex):
f[i] = ff[i].astype(float)
else:
f[i] = ff[i]
# Constraints Assigment
for i in range(len(opt_problem.constraints.keys())):
if isinstance(gg[i], complex):
g[i] = gg[i].astype(float)
else:
g[i] = gg[i]
return f, g
# ======================================================================
# KSOPT - Objective/Constraint Gradients Function
# ======================================================================
def ksgrd(nv, no, nc, x, f, g, df, dg):
if self.h_start:
dff = []
dgg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
dff, dgg = gradient.getGrad(x, group_ids, f, g, *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Gradient Assignment
for i in range(len(opt_problem.variables.keys())):
for j in range(len(opt_problem.objectives.keys())):
df[j, i] = dff[j, i]
for j in range(len(opt_problem.constraints.keys())):
dg[j, i] = dgg[j, i]
return df, dg
# Variables Handling
nvar = len(opt_problem.variables.keys())
xl = []
xu = []
xx = []
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xx.append(opt_problem.variables[key].value)
elif opt_problem.variables[key].type == 'i':
raise IOError('KSOPT cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('KSOPT cannot handle discrete design variables')
xl = numpy.array(xl)
xu = numpy.array(xu)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
gg = []
if ncon > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
raise IOError('KSOPT cannot handle equality constraints')
gg.append(opt_problem.constraints[key].value)
gg = numpy.array(gg, numpy.float)
else:
ncon = 1
gg = numpy.array([0], numpy.float)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff, numpy.float)
# Setup argument list values
ndv = numpy.array([nvar], numpy.int)
nob = numpy.array([nobj], numpy.int)
ncn = numpy.array([ncon], numpy.int)
nwork0 = 63
nwork1 = 3 * nobj + ncon + 12 * nvar + nvar * (nvar + 1)
nwork2 = nobj * nvar + ncon * nvar
nwork3 = 2 * max(2 * nvar, nobj + ncon)
nworkS = nwork0 + nwork1 + nwork2 + nwork3
nwork = numpy.array([nworkS], numpy.int)
# work = numpy.zeros([nwork], numpy.float)
# VisibleDeprecationWarning: converting an array with ndim > 0 to an
# index will result in an error in the future
work = numpy.zeros(nwork, numpy.float)
itmax = numpy.array([self.options['ITMAX'][1]], numpy.int)
rdfun = numpy.array([self.options['RDFUN'][1]], numpy.float)
rhomin = numpy.array([self.options['RHOMIN'][1]], numpy.float)
rhomax = numpy.array([self.options['RHOMAX'][1]], numpy.float)
iout = numpy.array([self.options['IOUT'][1]], numpy.int)
if myrank == 0:
if 0 <= self.options['IPRINT'][1] <= 3:
iprint = numpy.array([self.options['IPRINT'][1]], numpy.int)
else:
raise IOError('Incorrect Output Level Setting')
else:
iprint = numpy.array([0], numpy.int)
ifile = self.options['IFILE'][1]
if iprint > 0:
if os.path.isfile(ifile):
os.remove(ifile)
nfun = numpy.array([0], numpy.int)
ngrd = numpy.array([0], numpy.int)
# Run KSOPT
t0 = time.time()
ksopt.ksmain(ndv, nob, ncn, xx, xl, xu, ff, gg, work, nwork, itmax,
rdfun, rhomin, rhomax, iout, iprint, ifile, nfun, ngrd,
ksobj, ksgrd)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
ksopt.closeunit(self.options['IOUT'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = []
sol_inform['text'] = {}
if store_sol:
sol_name = 'KSOPT Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = nfun[0] + ngrd[0] * nvar
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if ncon > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = gg[i]
i += 1
else:
sol_cons = {}
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
store_hst=False,
hot_start=False,
disp_opts=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity setp size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the objective
function call.
Documentation last updated: February. 2, 2011 - Ruben E. Perez
"""
nec = 0
nic = 0
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
nec += 1
if opt_problem.constraints[key].type == 'i':
nic += 1
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pyFSQP - Current implementation only "
"allows single level parallelization, "
"either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyFSQP: Parallel objective Function Analysis '
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['ifile'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step,
*args, **kwargs)
# ======================================================================
# FSQP - Objective/Constraint Values Storage
# ======================================================================
def eval(x):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function (Real Valued)
fail = 0
f = []
g = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[f, g, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
# end
if self.h_start and self.pll:
[f, g, fail] = Bcast([f, g, fail], root=0)
elif not self.h_start:
[f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(f, 'obj')
log_file.write(g, 'con')
log_file.write(fail, 'fail')
# Objective Assignment
if isinstance(f, float):
f = [f]
for i in range(len(opt_problem.objectives.keys())):
if isinstance(f[i], complex):
ff[i] = f[i].astype(float)
else:
ff[i] = f[i]
# Constraints Assignment
i = 0
for j in range(len(opt_problem.constraints.keys())):
if isinstance(g[j], complex):
gg[i] = g[j].astype(float)
else:
gg[i] = g[j]
i += 1
# Gradients
if self.h_start:
dff = []
dgg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
dff, dgg = gradient.getGrad(x, group_ids, f, g, *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Store
self.stored_data['x'] = copy.copy(x)
self.stored_data['f'] = copy.copy(ff)
self.stored_data['g'] = copy.copy(gg)
self.stored_data['df'] = copy.copy(dff)
self.stored_data['dg'] = copy.copy(dgg)
return
# ======================================================================
# FSQP - Objective Values Function
# ======================================================================
def obj(nparam, j, x, fj):
if (self.stored_data['x'] != x).any():
eval(x)
ff = self.stored_data['f']
if nobj == 1:
fj = ff
else:
if isinstance(ff, list):
ff = numpy.array(ff)
fj = ff[j - 1]
return fj
# ======================================================================
# FSQP - Constraint Values Function
# ======================================================================
def cntr(nparam, j, x, gj):
# for given j, assign to gj the value of the jth constraint
# evaluated at x
if (self.stored_data['x'] != x).any():
eval(x)
gg = self.stored_data['g']
if j <= nic:
jg = nec + (j - 1)
else:
jg = (j - 1) - nic
gj = gg[jg]
return gj
# ======================================================================
# FSQP - Objective Gradients Function
# ======================================================================
def gradobj(nparam, j, x, gradfj, obj):
# assign to gradfj the gradient of the jth objective
# function evaluated at x
if (self.stored_data['x'] != x).any():
eval(x)
df = self.stored_data['df']
for i in range(len(opt_problem.variables.keys())):
gradfj[i] = df[j - 1, i]
return gradfj
# ======================================================================
# FSQP - Constraint Gradients Function
# ======================================================================
def gradcntr(nparam, j, x, gradgj, obj):
# assign to gradgj the gradient of the jth constraint evaluated at x
if (self.stored_data['x'] != x).any():
eval(x)
dg = self.stored_data['dg']
if j <= nic:
jg = nec + (j - 1)
else:
jg = (j - 1) - nic
gradgj = dg[jg]
return gradgj
# Variables Handling
nvar = len(opt_problem.variables.keys())
xl = []
xu = []
xx = []
for key in opt_problem.variables.keys():
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xx.append(opt_problem.variables[key].value)
xl = numpy.array(xl)
xu = numpy.array(xu)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
neqc = 0
gg = []
if ncon > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
neqc += 1
gg.append(opt_problem.constraints[key].value)
gg = numpy.array(gg, numpy.float)
else:
gg = numpy.array([0], numpy.float)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff, numpy.float)
# Setup argument list values
nparam = numpy.array([nvar], numpy.int)
nf = numpy.array([nobj], numpy.int)
nineqn = numpy.array([ncon - neqc], numpy.int)
nineq = nineqn
neqn = numpy.array([neqc], numpy.int)
neq = neqn
mode = numpy.array([self.options['mode'][1]], numpy.int)
if myrank == 0:
if self.options['iprint'][1] >= 0:
iprint = numpy.array([self.options['iprint'][1]], numpy.int)
else:
raise IOError('Incorrect Output Level Setting')
else:
iprint = numpy.array([0], numpy.int)
iout = numpy.array([self.options['iout'][1]], numpy.int)
ifile = self.options['ifile'][1]
if iprint > 0:
if os.path.isfile(ifile):
os.remove(ifile)
miter = numpy.array([self.options['miter'][1]], numpy.int)
inform = numpy.array([0], numpy.int)
bigbnd = numpy.array([self.options['bigbnd'][1]], numpy.float)
epstol = numpy.array([self.options['epstol'][1]], numpy.float)
epsneq = numpy.array([self.options['epseqn'][1]], numpy.float)
udelta = numpy.array([0], numpy.float)
iwsizeM = 6 * nvar + 8 * max([1, ncon]) + 7 * max([1, nobj]) + 30
iwsize = numpy.array([iwsizeM], numpy.int)
iw = numpy.zeros([iwsize], numpy.float)
nwsizeM = 4 * nvar**2 + 5 * max([1, ncon]) * nvar + 3 * max([
1, nobj
]) * nvar + 26 * (nvar + max([1, nobj])) + 45 * max([1, ncon]) + 100
nwsize = numpy.array([nwsizeM], numpy.int)
w = numpy.zeros([nwsize], numpy.float)
# Storage Arrays
self.stored_data = {}
self.stored_data['x'] = {} # numpy.zeros([nvar],float)
self.stored_data['f'] = {} # numpy.zeros([nobj],float)
self.stored_data['g'] = {} # numpy.zeros([ncon],float)
self.stored_data['df'] = {} # numpy.zeros([nvar],float)
self.stored_data['dg'] = {} # numpy.zeros([ncon,nvar],float)
# Run FSQP
t0 = time.time()
ffsqp.ffsqp(nparam, nf, nineqn, nineq, neqn, neq, mode, iprint, miter,
inform, bigbnd, epstol, epsneq, udelta, xl, xu, xx, ff, gg,
iw, iwsize, w, nwsize, obj, cntr, gradobj, gradcntr, iout,
ifile)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
ffsqp.closeunit(self.options['iout'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = inform[0]
sol_inform['text'] = self.getInform(inform[0])
if store_sol:
sol_name = 'FSQP Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = 0
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if ncon > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = gg[i]
i += 1
else:
sol_cons = {}
if ncon > 0:
sol_lambda = numpy.zeros(ncon, float)
for i in range(ncon):
sol_lambda[i] = w[nvar + i]
else:
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
disp_opts=False,
store_hst=False,
hot_start=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity step size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the objective
function call.
Documentation last updated: February. 2, 2011 - Peter W. Jansen
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pySLSQP - Current implementation only "
"allows single level parallelization, "
"either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print("pySLSQP: Parallel objective Function Analysis "
"requires mpi4py")
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['IFILE'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step)
# ======================================================================
# SLSQP - Objective/Constraint Values Function
# ======================================================================
def slfunc(m, me, la, n, f, g, x):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function
fail = 0
ff = []
gg = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[ff, gg, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[ff, gg, fail] = Bcast([ff, gg, fail], root=0)
elif not self.h_start:
[ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(ff, 'obj')
log_file.write(gg, 'con')
log_file.write(fail, 'fail')
# Objective Assignment
if isinstance(ff, complex):
f = ff.astype(float)
else:
f = ff
# Constraints Assignment (negative gg as slsqp uses g(x) >= 0)
for i in range(len(opt_problem.constraints.keys())):
if isinstance(gg[i], complex):
g[i] = -gg[i].astype(float)
else:
g[i] = -gg[i]
return f, g
# ======================================================================
# SLSQP - Objective/Constraint Gradients Function
# ======================================================================
def slgrad(m, me, la, n, f, g, df, dg, x):
if self.h_start:
dff = []
dgg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
dff, dgg = gradient.getGrad(x, group_ids, [f], -g, *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Gradient Assignment
for i in range(len(opt_problem.variables.keys())):
df[i] = dff[0, i]
for jj in range(len(opt_problem.constraints.keys())):
dg[jj, i] = -dgg[jj, i]
return df, dg
# Variables Handling
n = len(opt_problem.variables.keys())
xl = []
xu = []
xx = []
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xx.append(opt_problem.variables[key].value)
elif opt_problem.variables[key].type == 'i':
raise IOError('SLSQP cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('SLSQP cannot handle discrete design variables')
xl = numpy.array(xl)
xu = numpy.array(xu)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
m = len(opt_problem.constraints.keys())
meq = 0
# gg = []
if m > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
meq += 1
# gg.append(opt_problem.constraints[key].value)
# gg = numpy.array(gg,numpy.float)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff, numpy.float)
# Setup argument list values
# la = numpy.array([max(m, 1)], numpy.int)
la = max(m, 1)
# gg = numpy.zeros([la], numpy.float)
# VisibleDeprecationWarning: converting an array with ndim > 0 to an
# index will result in an error in the future
gg = numpy.zeros(la, numpy.float)
n1 = numpy.array([n + 1], numpy.int)
df = numpy.zeros([n + 1], numpy.float)
# VisibleDeprecationWarning: converting an array with ndim > 0
# to an index will result in an error in the future
# Corrected by the modification of la some lines above
dg = numpy.zeros([la, n + 1], numpy.float)
acc = numpy.array([self.options['ACC'][1]], numpy.float)
maxit = numpy.array([self.options['MAXIT'][1]], numpy.int)
iprint = numpy.array([self.options['IPRINT'][1]], numpy.int)
if myrank != 0:
iprint = -1
else:
iprint = self.options['IPRINT'][1]
# end
iout = numpy.array([self.options['IOUT'][1]], numpy.int)
ifile = self.options['IFILE'][1]
if iprint >= 0:
if os.path.isfile(ifile):
os.remove(ifile)
mode = numpy.array([0], numpy.int)
mineq = m - meq + 2 * (n + 1)
lsq = (n + 1) * ((n + 1) + 1) + meq * ((n + 1) + 1) + mineq * (
(n + 1) + 1)
lsi = ((n + 1) - meq + 1) * (mineq + 2) + 2 * mineq
lsei = ((n + 1) + mineq) * ((n + 1) - meq) + 2 * meq + (n + 1)
slsqpb = (n + 1) * (n / 2) + 2 * m + 3 * n + 3 * (n + 1) + 1
lwM = lsq + lsi + lsei + slsqpb + n + m
lw = numpy.array([lwM], numpy.int)
# w = numpy.zeros([lw], numpy.float)
# VisibleDeprecationWarning: converting an array with ndim > 0 to an
# index will result in an error in the future
w = numpy.zeros(lw, numpy.float)
ljwM = max(mineq, (n + 1) - meq)
ljw = numpy.array([ljwM], numpy.int)
# jw = numpy.zeros([ljw], numpy.intc)
# VisibleDeprecationWarning: converting an array with ndim > 0 to an
# index will result in an error in the future
jw = numpy.zeros(ljw, numpy.intc)
nfunc = numpy.array([0], numpy.int)
ngrad = numpy.array([0], numpy.int)
# Run SLSQP
t0 = time.time()
slsqp.slsqp(m, meq, la, n, xx, xl, xu, ff, gg, df, dg, acc, maxit,
iprint, iout, ifile, mode, w, lw, jw, ljw, nfunc, ngrad,
slfunc, slgrad)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
slsqp.closeunit(self.options['IOUT'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = mode[0]
sol_inform['text'] = self.getInform(mode[0])
if store_sol:
sol_name = 'SLSQP Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = 0
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if m > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = -gg[i]
i += 1
else:
sol_cons = {}
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
store_hst=False,
hot_start=False,
disp_opts=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity step size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the objective
function call.
Documentation last updated: February. 2, 2013 - Ruben E. Perez
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pyFILTERSD - Current implementation "
"only allows single level "
"parallelization, either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyFILTERSD: Parallel objective Function Analysis '
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['ifile'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step,
*args, **kwargs)
# ======================================================================
# filterSD - Objective/Constraint Values Function (Real Valued)
# ======================================================================
def functions(n, m, x, f, g, user, iuser):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function
fail = 0
ff = []
gg = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[ff, gg, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[ff, gg, fail] = Bcast([ff, gg, fail], root=0)
elif not self.h_start:
[ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(ff, 'obj')
log_file.write(gg, 'con')
log_file.write(fail, 'fail')
# Store
self.stored_data['x'] = copy.copy(x)
self.stored_data['f'] = copy.copy(ff)
self.stored_data['g'] = copy.copy(gg)
# Objective Assigment
if isinstance(ff, complex):
f = ff.astype(float)
else:
f = ff
# Constraints Assigment
for i in range(len(opt_problem.constraints.keys())):
if isinstance(gg[i], complex):
g[i] = gg[i].astype(float)
else:
g[i] = gg[i]
return f, g
# ======================================================================
# filterSD - Objective/Constraint Gradients Function
# ======================================================================
def gradients(n, m, x, a, user, iuser):
if (self.stored_data['x'] != x).any():
f, g = functions(n, m, x, [], [], [], [])
else:
f = self.stored_data['f']
g = self.stored_data['g']
if self.h_start:
dff = []
dgg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
#
dff, dgg = gradient.getGrad(
x, group_ids, [f],
g[0:len(opt_problem.constraints.keys())], *args, **kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Gradient Assignment
for i in range(len(opt_problem.variables.keys())):
a[i, 0] = dff[0, i]
for i in range(len(opt_problem.variables.keys())):
for j in range(len(opt_problem.constraints.keys())):
a[i, j + 1] = dgg[j, i]
return a
# Variables Handling
nvar = len(opt_problem.variables.keys())
xl = []
xu = []
xx = []
for key in opt_problem.variables.keys():
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xx.append(opt_problem.variables[key].value)
xl = numpy.array(xl)
xu = numpy.array(xu)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
gg = []
if ncon > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
raise IOError(
'FILTERSD cannot handle equality constraints')
gg.append(opt_problem.constraints[key].value)
gg = numpy.array(gg, numpy.float)
else:
ncon = 1
gg = numpy.array([0], numpy.float)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff, numpy.float)
# Setup argument list values
nn = numpy.array([nvar], numpy.int)
mm = numpy.array([ncon], numpy.int)
# al = numpy.zeros([mm], numpy.float)
# VisibleDeprecationWarning: converting an array with ndim > 0 to an
# index will result in an error in the future
al = numpy.zeros(mm, numpy.float)
ubd = numpy.array([self.options['ubd'][1]], numpy.float)
rho = numpy.array([self.options['rho'][1]], numpy.float)
htol = numpy.array([self.options['htol'][1]], numpy.float)
rgtol = numpy.array([self.options['rgtol'][1]], numpy.float)
maxit = numpy.array([self.options['maxit'][1]], numpy.int)
maxgr = numpy.array([self.options['maxgr'][1]], numpy.int)
dchk = numpy.array([self.options['dchk'][1]], numpy.int)
dtol = numpy.array([self.options['dtol'][1]], numpy.float)
if myrank == 0:
if self.options['iprint'][1] >= 0:
iprint = numpy.array([self.options['iprint'][1]], numpy.int)
else:
raise IOError('Incorrect Output Level Setting')
else:
iprint = numpy.array([0], numpy.int)
iout = numpy.array([self.options['iout'][1]], numpy.int)
ifile = self.options['ifile'][1]
if iprint > 0:
if os.path.isfile(ifile):
os.remove(ifile)
ifail = numpy.array([0], numpy.int)
nfevs = numpy.array([0], numpy.int)
ngevs = numpy.array([0], numpy.int)
# Storage Arrays
self.stored_data = {}
self.stored_data['x'] = {}
self.stored_data['f'] = {}
self.stored_data['g'] = {}
# Run filterSD
t0 = time.time()
filtersd.filtersd_wrap(nn, mm, xx, xl, xu, al, ff, gg, inf, ubd, rho,
htol, rgtol, maxit, maxgr, dchk, dtol, iprint,
iout, ifile, ifail, nfevs, ngevs, functions,
gradients)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
filtersd.closeunit(self.options['iout'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = ifail[0]
sol_inform['text'] = self.getInform(ifail[0])
if store_sol:
sol_name = 'FILTERSD Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = nfevs[0] + ngevs[0] * nvar
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if ncon > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = gg[i]
i += 1
else:
sol_cons = {}
if ncon > 0:
sol_lambda = numpy.zeros(ncon, float)
for i in range(ncon):
sol_lambda[i] = al[i]
else:
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
time.sleep(0)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
disp_opts=False,
store_hst=False,
hot_start=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity setp size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the
objective function call,
Documentation last updated: February. 2, 2011 - Peter W. Jansen
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError(
"pyGCMMA - Current implementation only allows single level "
"parallelization, either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyGCMMA: Parallel objective Function Analysis'
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['IFILE'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step)
# ======================================================================
# GCMMA - Objective/Constraint Values Function
# ======================================================================
def func1(m, n, xmma, f0new, fnew):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = xmma[group_ids[group][0]]
else:
xg[group] = xmma[
group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = xmma
# Flush Output Files
self.flushFiles()
# Evaluate User Function (Real Valued)
fail = 0
f = []
g = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[f, g, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[f, g, fail] = Bcast([f, g, fail], root=0)
elif not self.h_start:
[f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(xmma, 'x')
log_file.write(f, 'obj')
log_file.write(g, 'con')
log_file.write(fail, 'fail')
# Objective Assigment
if isinstance(f, complex):
f0new = f.astype(float)
else:
f0new = f
# Constraints Assigment
for i in range(len(opt_problem.constraints.keys())):
if isinstance(g[i], complex):
fnew[i] = g[i].astype(float)
else:
fnew[i] = g[i]
return f0new, fnew
# ======================================================================
# GCMMA - Objective/Constraint Values and Gradients Function
# ======================================================================
def func2(m, n, xval, f0val, df0dx, fval, dfdx):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = xval[group_ids[group][0]]
else:
xg[group] = xval[
group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = xval
# Flush Output Files
self.flushFiles()
# Evaluate User Function (Real Valued)
fail = 0
f = []
g = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[f, g, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[f, g, fail] = Bcast([f, g, fail], root=0)
elif not self.h_start:
[f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(xval, 'x')
log_file.write(f, 'obj')
log_file.write(g, 'con')
log_file.write(fail, 'fail')
# Gradients
if self.h_start:
df = []
dg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
df = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[df, dg] = Bcast([df, dg], root=0)
if not self.h_start:
df, dg = gradient.getGrad(xval, group_ids, [f], g, *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(df, 'grad_obj')
log_file.write(dg, 'grad_con')
# Objective Assignment
if isinstance(f, complex):
f0val = f.astype(float)
else:
f0val = f
# Constraints Assignment
for i in range(len(opt_problem.constraints.keys())):
if isinstance(g[i], complex):
fval[i] = g[i].astype(float)
else:
fval[i] = g[i]
# Gradients Assigment
k = 0
for i in range(len(opt_problem.variables.keys())):
if isinstance(df[0, i], complex):
df0dx[i] = df[0, i].astype(float)
else:
df0dx[i] = df[0, i]
for jj in range(len(opt_problem.constraints.keys())):
if isinstance(dg[jj, i], complex):
dfdx[k] = dg[jj, i].astype(float)
else:
dfdx[k] = dg[jj, i]
k += 1
return f0val, df0dx, fval, dfdx
# Variables Handling
n = len(opt_problem.variables.keys())
xmin = []
xmax = []
xval = []
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
xmin.append(opt_problem.variables[key].lower)
xmax.append(opt_problem.variables[key].upper)
xval.append(opt_problem.variables[key].value)
elif opt_problem.variables[key].type == 'i':
raise IOError('GCMMA cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('GCMMA cannot handle discrete design variables')
xmin = numpy.array(xmin)
xmax = numpy.array(xmax)
xval = numpy.array(xval)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
m = len(opt_problem.constraints.keys())
neqc = 0
# fval = []
fmax = []
if m > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
raise IOError('GCMMA cannot handle equality constraints')
# neqc += 1
# fval.append(opt_problem.constraints[key].value)
fmax.append(opt_problem.constraints[key].upper)
else:
m = 1
fmax.append(inf)
# fval = numpy.array(fval)
fmax = numpy.array(fmax)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
f0val = []
for key in opt_problem.objectives.keys():
f0val.append(opt_problem.objectives[key].value)
f0val = numpy.array(f0val)
# Setup argument list values
xmma = numpy.zeros([n], numpy.float)
# Space used internally by the program
# for the asymptotes (xlow and xupp) and
# computed bounds on x (alpha and beta)
xlow = numpy.zeros([n], numpy.float)
xupp = numpy.zeros([n], numpy.float)
alfa = numpy.zeros([n], numpy.float)
beta = numpy.zeros([n], numpy.float)
# The objective and constraint function
# values and space for the gradients
fval = numpy.zeros([m], numpy.float)
df0dx = numpy.zeros([n], numpy.float)
dfdx = numpy.zeros([m * n], numpy.float)
# Space for the coefficients and artificial
# variables to be computed (set to default values)
p = numpy.zeros([m * n], numpy.float)
q = numpy.zeros([m * n], numpy.float)
p0 = numpy.zeros([n], numpy.float)
q0 = numpy.zeros([n], numpy.float)
b = numpy.zeros([m], numpy.float)
y = numpy.zeros([m], numpy.float)
z = numpy.array([0.], numpy.float)
a = numpy.zeros([m], numpy.float)
c = 10000 * numpy.ones([m], numpy.float)
# Space for evaluating the convex approximation of
# the objective and constraint functions
f0app = numpy.array([0.], numpy.float)
fapp = numpy.zeros([m], numpy.float)
# Space for the parameter rho for the objective and
# constraint functions (used in evaluating p and q)
raa0 = numpy.array([0.], numpy.float)
raa = numpy.zeros([m], numpy.float)
# Space for the Lagrange multipliers (ulam)
# the gradient of the dual objective function,
# search direction, and Hessian of the dual objective
ulam = numpy.ones([m], numpy.float)
gradf = numpy.zeros([m], numpy.float)
dsrch = numpy.zeros([m], numpy.float)
hessf = numpy.zeros([m * (m + 1) / 2], numpy.float)
# Specify that all variables are free to move
iyfree = numpy.ones([m], numpy.int)
iter = numpy.array([0], numpy.int)
inntot = numpy.array([0], numpy.int)
maxit = numpy.array([self.options['MAXIT'][1]], numpy.int)
innmax = numpy.array([self.options['INNMAX'][1]], numpy.int)
geps = numpy.array([self.options['GEPS'][1]], numpy.float)
dabobj = numpy.array([self.options['DABOBJ'][1]], numpy.float)
delobj = numpy.array([self.options['DELOBJ'][1]], numpy.float)
itrm = numpy.array([self.options['ITRM'][1]], numpy.int)
inform = numpy.array([0], numpy.int)
if myrank == 0:
iprint = numpy.array([self.options['IPRINT'][1]], numpy.int)
else:
iprint = numpy.array([0], numpy.int)
iout = numpy.array([self.options['IOUT'][1]], numpy.int)
ifile = self.options['IFILE'][1]
if myrank == 0:
if iprint >= 0:
if os.path.isfile(ifile):
os.remove(ifile)
nfunc1 = numpy.array([0], numpy.int)
nfunc2 = numpy.array([0], numpy.int)
# Run GCMMA
t0 = time.time()
gcmma.gcmma(n, m, innmax, iter, maxit, inntot, geps, dabobj, delobj,
itrm, inform, xval, xmma, xmin, xmax, xlow, xupp, alfa,
beta, f0val, fval, fmax, df0dx, dfdx, p, q, p0, q0, b,
f0app, fapp, raa0, raa, y, z, a, c, ulam, gradf, dsrch,
hessf, iyfree, iprint, iout, ifile, nfunc1, nfunc2, func1,
func2)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
gcmma.closeunit(self.options['IOUT'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = inform[0]
sol_inform['text'] = self.getInform(inform[0])
if store_sol:
sol_name = 'GCMMA Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'display_opts' in sol_options:
del sol_options['defaults']
sol_evals = iter
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xmma[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = f0val[i]
i += 1
if m > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = fval[i]
i += 1
else:
sol_cons = {}
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return f0val, xmma, sol_inform
def __solve__(self, opt_problem, sens_type='FD', store_sol=True,
store_hst=False, hot_start=False, disp_opts=False,
sens_mode='', sens_step={}, *args, **kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity step size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the objective
function call.
Documentation last updated: February. 2, 2011 - Peter W. Jansen
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pySOLVOPT - Current implementation only "
"allows single level parallelization, "
"either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pySOLVOPT: Parallel objective Function Analysis '
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['ifile'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(opt_problem.name,
store_hst, hot_start,
def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step)
# ======================================================================
# SOLVOPT - Objective/Constraint Values Storage
# ======================================================================
def soeval(x):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function
fail = 0
f = []
g = []
if myrank == 0:
if self.h_start:
[vals, hist_end] = hos_file.read(
ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[f, g, fail] = [vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[f, g, fail] = Bcast([f, g, fail], root=0)
elif not self.h_start:
[f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(f, 'obj')
log_file.write(g, 'con')
log_file.write(fail, 'fail')
# Gradients
if self.h_start:
df = []
dg = []
if myrank == 0:
[vals, hist_end] = hos_file.read(
ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
df = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[df, dg] = Bcast([df, dg], root=0)
if not self.h_start:
df, dg = gradient.getGrad(x, group_ids, [f], g, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(df, 'grad_obj')
log_file.write(dg, 'grad_con')
# Objective Assignment
if isinstance(f, complex):
ff = f.astype(float)
else:
ff = f
# Constraints Assignment
i = 0
j = 0
for j in range(len(opt_problem.constraints.keys())):
if isinstance(g[j], complex):
gg[i] = g[j].astype(float)
else:
gg[i] = g[j]
i += 1
for key in opt_problem.variables.keys():
if opt_problem.variables[key].lower != -inf:
gg[i] = xl[j] - x[j]
i += 1
if opt_problem.variables[key].upper != inf:
gg[i] = x[j] - xu[j]
i += 1
# Gradient Assignment
df = df[0]
dgg = numpy.zeros([len(opt_problem.variables.keys()) * 2,
len(opt_problem.variables.keys())], 'd')
i = len(opt_problem.constraints.keys())
j = 0
for key in opt_problem.variables.keys():
if opt_problem.variables[key].lower != -inf:
if gg[i] > 0:
dgg[j, j] = -1
i += 1
if opt_problem.variables[key].upper != inf:
if gg[i] > 0:
dgg[j, j] = 1
i += 1
j += 1
dg = numpy.concatenate((dg, dgg), axis=0)
# Store
self.stored_data['x'] = copy.copy(x)
self.stored_data['f'] = copy.copy(ff)
self.stored_data['g'] = copy.copy(gg)
self.stored_data['df'] = copy.copy(df)
self.stored_data['dg'] = copy.copy(dg)
return
# ======================================================================
# SOLVOPT - Objective Value Function
# ======================================================================
def soobjf(n, x, f):
if (self.stored_data['x'] != x).any():
soeval(x)
f = self.stored_data['f']
return f
# ======================================================================
# SOLVOPT - Constraint Values Function
# ======================================================================
def soobjg(n, x, g):
if (self.stored_data['x'] != x).any():
soeval(x)
# Constraints Maximal Residual
maxg = numpy.zeros([len(self.stored_data['g'])], float)
i = 0
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
maxg[i] = abs(self.stored_data['g'][i])
i += 1
elif opt_problem.constraints[key].type == 'i':
maxg[i] = max(0, self.stored_data['g'][i])
i += 1
for j in range(len(opt_problem.constraints),
len(self.stored_data['g'])):
maxg[i] = max(0, self.stored_data['g'][i])
i += 1
g = max(maxg)
return g
# ======================================================================
# SOLVOPT - Objective Gradients Function
# ======================================================================
def sogrdf(n, x, df):
if (self.stored_data['x'] != x).any():
soeval(x)
df = self.stored_data['df']
return df
# ======================================================================
# SOLVOPT - Constraint Gradients Function
# ======================================================================
def sogrdg(n, x, dg):
if (self.stored_data['x'] != x).any():
soeval(x)
# Constraints Maximal Residual
maxg = numpy.zeros([len(self.stored_data['g'])], float)
i = 0
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
maxg[i] = abs(self.stored_data['g'][i])
i += 1
elif opt_problem.constraints[key].type == 'i':
maxg[i] = max(0, self.stored_data['g'][i])
i += 1
for j in range(len(opt_problem.constraints),
len(self.stored_data['g'])):
maxg[i] = max(0, self.stored_data['g'][i])
i += 1
id = min(numpy.nonzero(maxg == max(maxg))[0])
dg = self.stored_data['dg'][id]
return dg
# Variables Handling
nvar = len(opt_problem.variables.keys())
xl = []
xu = []
xx = []
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xx.append(opt_problem.variables[key].value)
elif opt_problem.variables[key].type == 'i':
raise IOError('SOLVOPT cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('SOLVOPT cannot handle discrete design variables')
xl = numpy.array(xl)
xu = numpy.array(xu)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [k,
k + group_len]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
neqc = 0
gg = []
if ncon > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
neqc += 1
# gg.append(opt_problem.constraints[key].value)
gg.append(opt_problem.constraints[key].upper)
nadd = 0
for key in opt_problem.variables.keys():
if opt_problem.variables[key].lower != -inf:
gg.append(0)
nadd += 1
if opt_problem.variables[key].upper != inf:
gg.append(0)
nadd += 1
gg = numpy.array(gg, numpy.float)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff, numpy.float)
# Setup argument list values
n = numpy.array([nvar], numpy.int)
flg = numpy.array([True], numpy.bool)
iprint = self.options['iprint'][1]
if myrank != 0:
iprint = -1
else:
iprint = self.options['iprint'][1]
options = numpy.zeros([13], numpy.float)
options[0] = -1 # Minimize
options[1] = self.options['xtol'][1] # Variables Tolerance
options[2] = self.options['ftol'][1] # Objective Tolerance
options[3] = self.options['maxit'][1] # Maximum Number of Iterations
options[4] = iprint # Output Level
options[5] = self.options['gtol'][1] # Constraints Tolerance
options[6] = self.options['spcdil'][1] # Space Dilation
options[
7] = 1e-11 # LB FD Stepsize (NA as we provide our own sensitivities)
flfc = numpy.array([True], numpy.bool)
flgc = numpy.array([True], numpy.bool)
iout = numpy.array([self.options['iout'][1]], numpy.int)
ifile = self.options['ifile'][1]
if iprint >= 0:
if os.path.isfile(ifile):
os.remove(ifile)
wb = numpy.zeros([nvar, nvar], numpy.float)
wg = numpy.zeros([nvar], numpy.float)
wg0 = numpy.zeros([nvar], numpy.float)
wg1 = numpy.zeros([nvar], numpy.float)
wgt = numpy.zeros([nvar], numpy.float)
wgc = numpy.zeros([nvar], numpy.float)
wz = numpy.zeros([nvar], numpy.float)
wx1 = numpy.zeros([nvar], numpy.float)
wxopt = numpy.zeros([nvar], numpy.float)
wxrec = numpy.zeros([nvar], numpy.float)
wgrec = numpy.zeros([nvar], numpy.float)
wxx = numpy.zeros([nvar], numpy.float)
wdeltax = numpy.zeros([nvar], numpy.float)
widx = numpy.zeros([nvar], numpy.int)
# Storage Arrays
self.stored_data = {}
self.stored_data['x'] = {} # numpy.zeros([nvar],float)
self.stored_data['f'] = {} # numpy.zeros([nobj],float)
self.stored_data['g'] = {} # numpy.zeros([ncon+nadd],float)
self.stored_data['df'] = {} # numpy.zeros([nvar],float)
self.stored_data['dg'] = {} # numpy.zeros([ncon+nadd,nvar],float)
# Run SOLVOPT
t0 = time.time()
solvopt.solvopt(n, xx, ff, soobjf, flg, sogrdf, options, flfc, soobjg,
flgc, sogrdg, wb, wg, wg0, wg1, wgt, wgc, wz, wx1,
wxopt, wxrec, wgrec, wxx, wdeltax, widx, iout, ifile)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
solvopt.closeunit(self.options['iout'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = options[8]
sol_inform['text'] = self.getInform(options[8])
if store_sol:
sol_name = 'SOLVOPT Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
# assumes cnst fevals and gevals are included in feval & geval
sol_evals = options[9] + options[10]
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if ncon > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = gg[i]
i += 1
if i >= ncon:
break
else:
sol_cons = {}
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__, sol_name, objfunc,
sol_time,
sol_evals, sol_inform, sol_vars, sol_objs,
sol_cons, sol_options,
display_opts=disp_opts, Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank, arguments=args, **kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
store_hst=False,
hot_start=False,
disp_opts=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity setp size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the
objective function call.
Documentation last updated: February. 2, 2011 - Ruben E. Perez
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pyPSQP - Current implementation only "
"allows single level parallelization, "
"either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyPSQP: Parallel objective Function Analysis '
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['IFILE'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step)
# ======================================================================
# PSQP - Objective/Constraint Values Storage
# ======================================================================
def eval(x):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function (Real Valued)
fail = 0
f = []
g = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[f, g, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[f, g, fail] = Bcast([f, g, fail], root=0)
elif not self.h_start:
[f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(f, 'obj')
log_file.write(g, 'con')
log_file.write(fail, 'fail')
# Objective Assignment
if isinstance(f, float):
f = [f]
for i in range(len(opt_problem.objectives.keys())):
if isinstance(f[i], complex):
ff[i] = f[i].astype(float)
else:
ff[i] = f[i]
# Constraints Assignment
i = 0
for j in range(len(opt_problem.constraints.keys())):
if isinstance(g[j], complex):
gg[i] = g[j].astype(float)
else:
gg[i] = g[j]
i += 1
# Gradients
if self.h_start:
dff = []
dgg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
dff, dgg = gradient.getGrad(x, group_ids, f, g, *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Store
self.stored_data['x'] = copy.copy(x)
self.stored_data['f'] = copy.copy(ff)
self.stored_data['g'] = copy.copy(gg)
self.stored_data['df'] = copy.copy(dff)
self.stored_data['dg'] = copy.copy(dgg)
return
# ======================================================================
# PSQP - Objective Values Function
# ======================================================================
def pobj(n, x, f):
if (self.stored_data['x'] != x).any():
eval(x)
ff = self.stored_data['f']
return ff[0]
# ======================================================================
# PSQP - Constraint Values Function
# ======================================================================
def pcon(n, k, x, g):
if (self.stored_data['x'] != x).any():
eval(x)
gg = self.stored_data['g']
return gg[k - 1]
# ======================================================================
# PSQP - Objective Gradients Function
# ======================================================================
def pdobj(n, x, df):
if (self.stored_data['x'] != x).any():
eval(x)
df = self.stored_data['df']
return df[0]
# ======================================================================
# PSQP - Constraint Gradients Function
# ======================================================================
def pdcon(n, k, x, dg):
if (self.stored_data['x'] != x).any():
eval(x)
dg = self.stored_data['dg']
return dg[k - 1]
# Variables Handling
nvar = len(opt_problem.variables.keys())
xl = []
xu = []
xi = []
xx = []
for key in opt_problem.variables.keys():
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xi.append(3)
xx.append(opt_problem.variables[key].value)
xl = numpy.array(xl)
xu = numpy.array(xu)
xi = numpy.array(xi)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
if ncon > 0:
gi = []
gg = []
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
gi.append(5)
elif opt_problem.constraints[key].type == 'i':
gi.append(2)
gg.append(opt_problem.constraints[key].value)
gg.append(0.0)
gl = numpy.zeros([ncon], numpy.float)
gu = numpy.zeros([ncon], numpy.float)
gi = numpy.array(gi, numpy.float)
gg = numpy.array(gg, numpy.float)
else:
gl = numpy.array([0], numpy.float)
gu = numpy.array([0], numpy.float)
gi = numpy.array([0], numpy.float)
gg = numpy.array([0], numpy.float)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff, numpy.float)
# Setup argument list values
nf = numpy.array([nvar], numpy.int)
nc = numpy.array([ncon], numpy.int)
mit = numpy.array([self.options['MIT'][1]], numpy.int)
mfv = numpy.array([self.options['MFV'][1]], numpy.int)
met = numpy.array([self.options['MET'][1]], numpy.int)
mec = numpy.array([self.options['MEC'][1]], numpy.int)
xmax = numpy.array([self.options['XMAX'][1]], numpy.float)
tolx = numpy.array([self.options['TOLX'][1]], numpy.float)
tolc = numpy.array([self.options['TOLC'][1]], numpy.float)
tolg = numpy.array([self.options['TOLG'][1]], numpy.float)
rpf = numpy.array([self.options['RPF'][1]], numpy.float)
gmax = numpy.array([0], numpy.float)
cmax = numpy.array([0], numpy.float)
if myrank == 0:
if self.options['IPRINT'][1] <= 2:
iprint = numpy.array([self.options['IPRINT'][1]], numpy.int)
else:
raise IOError('Incorrect Output Level Setting')
else:
iprint = numpy.array([0], numpy.int)
iout = numpy.array([self.options['IOUT'][1]], numpy.int)
ifile = self.options['IFILE'][1]
if myrank == 0:
if iprint != 0:
if os.path.isfile(ifile):
os.remove(ifile)
iterm = numpy.array([0], numpy.int)
# Storage Arrays
self.stored_data = {}
self.stored_data['x'] = {} # numpy.zeros([nvar],float)
self.stored_data['f'] = {} # numpy.zeros([nobj],float)
self.stored_data['g'] = {} # numpy.zeros([ncon],float)
self.stored_data['df'] = {} # numpy.zeros([nvar],float)
self.stored_data['dg'] = {} # numpy.zeros([ncon,nvar],float)
# Run PSQP
t0 = time.time()
psqp.psqp_wrap(nf, nc, xx, xi, xl, xu, gg, gi, gl, gu, mit, mfv, met,
mec, xmax, tolx, tolc, tolg, rpf, ff, gmax, cmax,
iprint, iout, ifile, iterm, pobj, pdobj, pcon, pdcon)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
# Store Results
sol_inform = {}
sol_inform['value'] = iterm[0]
sol_inform['text'] = self.getInform(iterm[0])
if store_sol:
sol_name = 'PSQP Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = psqp.stat.nfv + psqp.stat.nfg * nvar
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if ncon > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = gg[i]
i += 1
else:
sol_cons = {}
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
disp_opts=False,
store_hst=False,
hot_start=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity setp size, *Default* = {}
[corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the
objective function call.
Documentation last updated: February. 2, 2011 - Peter W. Jansen
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pyALGENCAN - Current implementation "
"only allows single level "
"parallelization, either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyALGENCAN: Parallel objective Function Analysis '
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['ifile'][1].split('.')[0]
hos_file, log_file, tmp_file = \
self._setHistory(opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step)
def evalf(n, x, f, flag):
"""
Parameters
----------
n
x
f
flag
Returns
-------
"""
flag = -1
return f, flag
def evalg(n, x, g, flag):
"""
Parameters
----------
n
x
g
flag
Returns
-------
"""
flag = -1
return g, flag
def evalh(n, x, hlin, hcol, hval, hnnz, flag):
"""
Parameters
----------
n
x
hlin
hcol
hval
hnnz
flag
Returns
-------
"""
flag = -1
return hlin, hcol, hval, hnnz, flag
def evalc(n, x, ind, c, flag):
"""
Parameters
----------
n
x
ind
c
flag
Returns
-------
"""
flag = -1
return c, flag
def evaljac(n, x, ind, jcvar, jcval, jcnnz, flag):
"""
Parameters
----------
n
x
ind
jcvar
jcval
jcnnz
flag
Returns
-------
"""
flag = -1
return jcvar, jcval, jcnnz, flag
def evalgjacp(n, x, g, m, p, q, work, gotj, flag):
"""
Parameters
----------
n
x
g
m
p
q
work
gotj
flag
Returns
-------
"""
flag = -1
return g, p, q, gotj, flag
def evalhc(n, x, ind, hclin, hccol, hcval, hcnnz, flag):
"""
Parameters
----------
n
x
ind
hclin
hccol
hcval
hcnnz
flag
Returns
-------
"""
flag = -1
return hclin, hccol, hcval, hcnnz, flag
def evalhl(n, x, m, lmbda, scalef, scalec, hllin, hlcol, hlval, hlnnz,
flag):
"""
Parameters
----------
n
x
m
lmbda
scalef
scalec
hllin
hlcol
hlval
hlnnz
flag
Returns
-------
"""
flag = -1
return hllin, hlcol, hlval, hlnnz, flag
def evalhlp(n, x, m, lmbda, sf, sc, p, hp, goth, flag):
"""
Parameters
----------
n
x
m
lmbda
sf
sc
p
hp
goth
flag
Returns
-------
"""
flag = -1
return hp, goth, flag
# ======================================================================
# ALGENCAN - Objective/Constraint Values Function
# ======================================================================
def evalfc(n, x, f, m, g, flag):
"""
Parameters
----------
n
x
f
m
g
flag
Returns
-------
"""
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function
flag = 0
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[ff, gg, flag] = \
[vals['obj'][0][0],vals['con'][0],
int(vals['fail'][0][0])]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[ff, gg, fail] = Bcast([ff, gg, fail], root=0)
elif not self.h_start:
[ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(ff, 'obj')
log_file.write(gg, 'con')
log_file.write(fail, 'fail')
# Objective Assigment
if isinstance(ff, complex):
f = ff.astype(float)
else:
f = ff
# Constraints Assigment
for i in range(len(opt_problem.constraints.keys())):
if isinstance(gg[i], complex):
g[i] = gg[i].astype(float)
else:
g[i] = gg[i]
return f, g, fail
# ======================================================================
# ALGENCAN - Objective/Constraint Gradients Function
# ======================================================================
def evalgjac(n, x, jfval, m, jcfun, jcvar, jcval, jcnnz, flag):
"""
Parameters
----------
n
x
jfval
m
jcfun
jcvar
jcval
jcnnz
flag
Returns
-------
"""
if self.h_start:
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
[ff, gg, fail] = opt_problem.obj_fun(x, *args, **kwargs)
dff, dgg = gradient.getGrad(x, group_ids, [ff], gg, *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Objective Gradient Assignment
for i in range(len(opt_problem.variables.keys())):
jfval[i] = dff[0, i]
# Constraint Gradient Assignment
jcnnz = 0
for jj in range(len(opt_problem.constraints.keys())):
for ii in range(len(opt_problem.variables.keys())):
jcfun[jcnnz] = jj + 1
jcvar[jcnnz] = ii + 1
jcval[jcnnz] = dgg[jj, ii]
jcnnz += 1
return jfval, jcfun, jcvar, jcval, jcnnz, fail
# Variables Handling
n = len(opt_problem._variables.keys())
xl = []
xu = []
xx = []
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xx.append(opt_problem.variables[key].value)
elif opt_problem.variables[key].type == 'i':
raise IOError('NLPQL cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('NLPQL cannot handle discrete design variables')
xl = numpy.array(xl)
xu = numpy.array(xu)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = \
[k, k+group_len]
k += group_len
# Constraints Handling
m = len(opt_problem.constraints.keys())
equatn = []
linear = []
if m > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
equatn.append(True)
elif opt_problem.constraints[key].type == 'i':
equatn.append(False)
linear.append(False)
else:
raise IOError('ALGENCAN support for unconstrained problems '
'not implemented yet')
equatn = numpy.array(equatn)
linear = numpy.array(linear)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff)
# Setup argument list values
nn = numpy.array([n], numpy.int)
mm = numpy.array([m], numpy.int)
lm = numpy.zeros([m], numpy.float)
coded = numpy.array([
False, False, False, False, False, False, True, True, False, False
], numpy.bool)
epsfeas = numpy.array([self.options['epsfeas'][1]], numpy.float)
epsopt = numpy.array([self.options['epsopt'][1]], numpy.float)
efacc = numpy.array([self.options['efacc'][1]], numpy.float)
eoacc = numpy.array([self.options['eoacc'][1]], numpy.float)
checkder = numpy.array([self.options['checkder'][1]], numpy.bool)
iprint = numpy.array([self.options['iprint'][1]], numpy.int)
if myrank != 0:
iprint = 0
else:
iprint = self.options['iprint'][1]
ncomp = numpy.array([self.options['ncomp'][1]], numpy.int)
ifile = self.options['ifile'][1]
if iprint >= 0:
if os.path.isfile(ifile):
os.remove(ifile)
cnormu = numpy.array([0], numpy.float)
snorm = numpy.array([0], numpy.float)
nlpsupn = numpy.array([0], numpy.float)
inform = numpy.array([0], numpy.int)
# Run ALGENCAN
t0 = time.time()
algencan.algencan(epsfeas, epsopt, efacc, eoacc, iprint, ncomp, nn, xx,
xl, xu, mm, lm, equatn, linear, coded, checkder, ff,
cnormu, snorm, nlpsupn, inform, ifile, evalf, evalg,
evalh, evalc, evaljac, evalhc, evalfc, evalgjac,
evalgjacp, evalhl, evalhlp)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
algencan.closeunit(10)
[fs, gg, fail] = opt_problem.obj_fun(xx, *args, **kwargs)
# Store Results
sol_inform = {}
sol_inform['value'] = inform[0]
sol_inform['text'] = self.getInform(inform[0])
if store_sol:
sol_name = 'ALGENCAN Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = 0
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if m > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = gg[i]
i += 1
else:
sol_cons = {}
sol_lambda = lm
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
store_hst=False,
hot_start=False,
disp_opts=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity setp size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the
objective function call.
Documentation last updated: February. 2, 2013 - Peter W. Jansen
"""
if self.pll_type is not None and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pyNLPQLP - Current implementation only "
"allows single level parallelization, "
"either 'POA', 'SMP', 'DPM' or 'pgc'")
if self.pll_type is not None or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyNLPQLP: Parallel objective Function Analysis or '
'gradient calculation requires mpi4py')
comm = MPI.COMM_WORLD
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
Barrier = comm.Barrier
Send = comm.Send
Recv = comm.Recv
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
Barrier = comm.barrier
Send = comm.send
Recv = comm.recv
self.pll = True
if self.pll_type == 'SPM':
nproc = comm.Get_size()
else:
nproc = 1
self.myrank = comm.Get_rank()
else:
self.pll = False
nproc = 1
self.myrank = 0
myrank = self.myrank
def_fname = self.options['IFILE'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step,
*args, **kwargs)
# ======================================================================
# NLPQLP - Objective/Constraint Values Function
# ======================================================================
def nlfunc(l, nmax, mmax, x, lactive, active, f, g):
if self.pll_type == 'SPM':
mxi = myrank
else:
mxi = 0
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0], mxi]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1],
mxi]
xn = xg
else:
xn = x[:-1, mxi]
# Flush Output Files
self.flushFiles()
# Evaluate User Function
fail = 0
ff = []
gg = []
if myrank == 0:
if self.h_start:
for proc in range(l):
[vals, hist_end
] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[ff, gg, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
f[proc] = ff
g[:, proc] = gg
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[f, g] = Bcast([f, g], root=0)
elif not self.h_start:
[ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Objective Assignment
if isinstance(ff, complex):
f[mxi] = ff.astype(float)
else:
f[mxi] = ff
# Constraints Assignment (negative gg as nlpqlp uses g(x) >= 0)
for i in range(len(opt_problem.constraints.keys())):
if isinstance(gg[i], complex):
g[i, mxi] = -gg[i].astype(float)
else:
g[i, mxi] = -gg[i]
if self.pll_type == 'SPM':
send_buf = {}
send_buf[myrank] = {'fi': f[mxi], 'gi': g[:, mxi]}
if myrank != 0:
Send(send_buf, dest=0)
else:
p_results = []
for proc in range(1, nproc):
p_results.append(Recv(source=proc))
if myrank == 0:
for proc in range(nproc - 1):
for i in p_results[proc].keys():
f[i] = p_results[proc][i]['fi']
g[:, i] = p_results[proc][i]['gi']
[f, g] = Bcast([f, g], root=0)
# Store History
if myrank == 0:
if self.sto_hst:
for proc in range(l):
log_file.write(x[:-1, proc], 'x')
log_file.write(f[proc], 'obj')
log_file.write(g[:, proc], 'con')
log_file.write(fail, 'fail')
return f, g
# ======================================================================
# NLPQLP - Objective/Constraint Gradients Function
# ======================================================================
def nlgrad(l, nmax, mmax, x, lactive, active, f, g, df, dg):
if self.h_start:
dff = []
dgg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
dff, dgg = gradient.getGrad(
x[:-1, 0], group_ids, [f[0]],
-g[0:len(opt_problem.constraints.keys()), 0], *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Gradient Assignment
for i in range(len(opt_problem.variables.keys())):
df[i] = dff[0, i]
for j in range(len(opt_problem.constraints.keys())):
dg[j, i] = -dgg[j, i]
return df, dg
# Variables Handling
nvar = len(opt_problem.variables.keys())
xl = numpy.zeros([max(2, nvar + 1)], numpy.float)
xu = numpy.zeros([max(2, nvar + 1)], numpy.float)
xx = numpy.zeros([max(2, nvar + 1), nproc], numpy.float)
i = 0
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
xl[i] = opt_problem.variables[key].lower
xu[i] = opt_problem.variables[key].upper
for proc in range(nproc):
xx[i, proc] = opt_problem.variables[key].value
elif opt_problem.variables[key].type == 'i':
raise IOError('NLPQLP cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('NLPQLP cannot handle discrete design variables')
i += 1
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
neqc = 0
gg = numpy.zeros([ncon, nproc], numpy.float)
if ncon > 0:
i = 0
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
neqc += 1
if self.pll is False:
gg[i, 0] = opt_problem.constraints[key].value
else:
for proc in range(nproc):
gg[i, proc] = opt_problem.constraints[key].value
i += 1
# Objective Handling
objfunc = opt_problem.obj_fun
if len(opt_problem.objectives.keys()) > 1:
raise IOError('NLPQLP cannot handle multi-objective problems')
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff * nproc, numpy.float)
# Setup argument list values
ll = numpy.array([nproc], numpy.int)
mm = numpy.array([ncon], numpy.int)
me = numpy.array([neqc], numpy.int)
mmax = numpy.array([max(1, mm)], numpy.int)
nn = numpy.array([nvar], numpy.int)
nmax = numpy.array([max(2, nn + 1)], numpy.int)
mnn2 = numpy.array([mmax + nmax + nmax + 2], numpy.int)
gg = numpy.zeros([mmax, ll], numpy.float)
df = numpy.zeros([nmax], numpy.float)
dg = numpy.zeros([mmax, nmax], numpy.float)
uu = numpy.zeros([mnn2], numpy.float)
cc = numpy.zeros([nmax, nmax], numpy.float)
dd = numpy.zeros([nmax], numpy.float)
acc = numpy.array([self.options['ACC'][1]], numpy.float)
accqp = numpy.array([self.options['ACCQP'][1]], numpy.float)
stpmin = numpy.array([self.options['STPMIN'][1]], numpy.float)
maxfun = numpy.array([self.options['MAXFUN'][1]], numpy.int)
maxit = numpy.array([self.options['MAXIT'][1]], numpy.int)
if nproc != 1:
maxnm = numpy.array([max(1, min(50, nproc))], numpy.int)
else:
maxnm = numpy.array([0], numpy.int)
rhob = self.options['RHOB'][1]
if 0 <= self.options['MODE'][1] <= 18:
mode = self.options['MODE'][1]
else:
raise IOError('Incorrect Mode Setting')
ifail = numpy.array([0], numpy.int)
if myrank == 0:
if 0 <= self.options['IPRINT'][1] <= 4:
iprint = numpy.array([self.options['IPRINT'][1]], numpy.int)
else:
raise IOError('Incorrect Output Level Setting')
else:
iprint = numpy.array([0], numpy.int)
iout = self.options['IOUT'][1]
ifile = self.options['IFILE'][1]
if iprint > 0:
if os.path.isfile(ifile):
os.remove(ifile)
lwa = numpy.array([
23 * nmax + 4 * mmax + 3 * mmax + 150 + 3 * nmax * nmax / 2 +
10 * nmax + nmax + mmax + 1
], numpy.int)
wa = numpy.zeros([lwa], numpy.float)
lkwa = numpy.array([25 + nmax], numpy.int)
kwa = numpy.zeros([lkwa], numpy.intc)
lactiv = numpy.array([2 * mmax + 10], numpy.int)
active = numpy.zeros([lactiv], numpy.bool)
lql = numpy.array([self.options['LQL'][1]], numpy.bool)
nfun = numpy.array([0], numpy.int)
ngrd = numpy.array([0], numpy.int)
# Run NLPQLP
t0 = time.time()
xx, ff, gg, uu, nfun, ngrd = nlpqlp.nlpqlp_wrap(
ll, mm, me, mmax, nn, nmax, mnn2, xx, ff, gg, df, dg, uu, xl, xu,
cc, dd, acc, accqp, stpmin, maxfun, maxit, maxnm, rhob, mode,
ifail, iprint, iout, ifile, wa, lwa, kwa, lkwa, active, lactiv,
lql, nfun, ngrd, nlfunc, nlgrad)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
nlpqlp.closeunit(self.options['IOUT'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = ifail[0]
sol_inform['text'] = self.getInform(ifail[0])
if store_sol:
sol_name = 'NLPQLP Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = nfun + ngrd * nvar
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i, 0]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[0]
i += 1
if ncon > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = -gg[i, 0]
i += 1
else:
sol_cons = {}
if ncon > 0:
sol_lambda = numpy.zeros(ncon, float)
for i in range(ncon):
sol_lambda[i] = uu[i]
else:
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
store_hst=False,
hot_start=False,
disp_opts=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity setp size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the
objective function call.
Documentation last updated: February. 2, 2011 - Ruben E. Perez
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError(
"pyMMFD - Current implementation only allows single level "
"parallelization, either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pyMMFD: Parallel objective Function Analysis'
' requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['IFILE'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step,
*args, **kwargs)
# ======================================================================
# MMFD - Objective/Constraint Values Function
# ======================================================================
def mmfdfun(nv, nc, x, f, g):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function
fail = 0
ff = []
gg = []
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[ff, gg, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[ff, gg, fail] = Bcast([ff, gg, fail], root=0)
elif not self.h_start:
[ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(ff, 'obj')
log_file.write(gg, 'con')
log_file.write(fail, 'fail')
# Objective Assignment
if isinstance(ff, complex):
f = ff.astype(float)
else:
f = ff
# Constraints Assignment
for i in range(len(opt_problem.constraints.keys())):
if isinstance(gg[i], complex):
g[i] = gg[i].astype(float)
else:
g[i] = gg[i]
return f, g
# ======================================================================
# MMFD - Objective/Constraint Gradients Function
# ======================================================================
def mmfdgrd(nv, nc, x, f, g, df, dg):
if self.h_start:
dff = []
dgg = []
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
dff = vals['grad_obj'][0].reshape(
(len(opt_problem.objectives.keys()),
len(opt_problem.variables.keys())))
dgg = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[dff, dgg] = Bcast([dff, dgg], root=0)
if not self.h_start:
dff, dgg = gradient.getGrad(x, group_ids, [f], g, *args,
**kwargs)
# Store History
if self.sto_hst and (myrank == 0):
log_file.write(dff, 'grad_obj')
log_file.write(dgg, 'grad_con')
# Gradient Assignment
for i in range(len(opt_problem.variables.keys())):
df[i] = dff[0, i]
for j in range(len(opt_problem.constraints.keys())):
dg[i, j] = dgg[j, i]
return df, dg
# Variables Handling
nvar = len(opt_problem.variables.keys())
xl = []
xu = []
xx = []
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
xl.append(opt_problem.variables[key].lower)
xu.append(opt_problem.variables[key].upper)
xx.append(opt_problem.variables[key].value)
elif opt_problem.variables[key].type == 'i':
raise IOError('MMFD cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('MMFD cannot handle discrete design variables')
xl = numpy.array(xl)
xu = numpy.array(xu)
xx = numpy.array(xx)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
neqc = 0
gg = []
idg = []
if ncon > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'i':
idg.append(1)
elif opt_problem.constraints[key].type == 'e':
idg.append(-1)
gg.append(opt_problem.constraints[key].value)
else:
raise IOError(
'MMFD support for unconstrained problems not implemented yet')
gg = numpy.array(gg)
idg = numpy.array(idg, numpy.int)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff)
# Setup argument list values
ndv = numpy.array([nvar], numpy.int)
ncn = numpy.array([ncon], numpy.int)
if 0 <= self.options['IOPT'][1] <= 1:
iopt = numpy.array([self.options['IOPT'][1]], numpy.int)
else:
raise IOError('Incorrect Feasible Directions Approach')
if 0 <= self.options['IONED'][1] <= 3:
ioned = numpy.array([self.options['IONED'][1]], numpy.int)
else:
raise IOError('Incorrect One-Dimensional Search Method')
if myrank == 0:
if 0 <= self.options['IPRINT'][1] <= 2:
iprint = numpy.array([self.options['IPRINT'][1]], numpy.int)
else:
raise IOError('Incorrect Output Level Setting')
else:
iprint = numpy.array([0], numpy.int)
# iout = numpy.array([self.options['IOUT'][1]], numpy.int)
ifile = self.options['IFILE'][1]
if iprint > 0:
if os.path.isfile(ifile):
os.remove(ifile)
ct = numpy.array([self.options['CT'][1]], numpy.float)
ctmin = numpy.array([self.options['CTMIN'][1]], numpy.float)
finit, ginit = mmfdfun([], [], xx, ff, gg)
dabobj = numpy.array([self.options['DABOBJ'][1] * finit], numpy.float)
delobj = numpy.array([self.options['DELOBJ'][1]], numpy.float)
thetaz = numpy.array([self.options['THETAZ'][1]], numpy.float)
pmlt = numpy.array([self.options['PMLT'][1]], numpy.float)
itmax = numpy.array([self.options['ITMAX'][1]], numpy.int)
itrmop = numpy.array([self.options['ITRMOP'][1]], numpy.int)
nrwk0 = 500
nrwk1 = 10 * (2 * nvar + ncon)
nrwk2 = (ncon + 2 * nvar + 3)
nrwk3 = (ncon + 2 * nvar) * ((ncon + 2 * nvar) / 2 + 1)
nrwkS = nrwk0 + nrwk1 + nrwk2 + nrwk3
nrwk = numpy.array([nrwkS], numpy.int)
wk = numpy.zeros([nrwk], numpy.float)
nriwk = numpy.array([nrwkS], numpy.int)
iwk = numpy.zeros([nriwk], numpy.int)
nfun = numpy.array([0], numpy.int)
ngrd = numpy.array([0], numpy.int)
# Run MMFD
t0 = time.time()
mmfd.mmfd(iopt, ioned, iprint, ndv, ncn, xx, xl, xu, ff, gg, idg, wk,
nrwk, iwk, nriwk, ifile, ct, ctmin, dabobj, delobj, thetaz,
pmlt, itmax, itrmop, nfun, ngrd, mmfdfun, mmfdgrd)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iprint > 0:
# mmfd.closeunit(self.options['IOUT'][1])
mmfd.closeunit(6)
# Store Results
sol_inform = {}
sol_inform['value'] = []
sol_inform['text'] = {}
if store_sol:
sol_name = 'MMFD Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = nfun[0] + ngrd[0] * nvar
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xx[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
if ncon > 0:
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = gg[i]
i += 1
else:
sol_cons = {}
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xx, sol_inform
def __solve__(self,
opt_problem,
sens_type='FD',
store_sol=True,
disp_opts=False,
store_hst=False,
hot_start=False,
sens_mode='',
sens_step={},
*args,
**kwargs):
"""Run Optimizer (Optimize Routine)
**Keyword arguments:**
- opt_problem -> INST: Optimization instance
- sens_type -> STR/FUNC: Gradient type, *Default* = 'FD'
- store_sol -> BOOL: Store solution in Optimization class flag,
*Default* = True
- disp_opts -> BOOL: Flag to display options in solution text,
*Default* = False
- store_hst -> BOOL/STR: Flag/filename to store optimization history,
*Default* = False
- hot_start -> BOOL/STR: Flag/filename to read optimization history,
*Default* = False
- sens_mode -> STR: Flag for parallel gradient calculation,
*Default* = ''
- sens_step -> FLOAT: Sensitivity step size,
*Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)]
Additional arguments and keyword arguments are passed to the objective
function call.
Documentation last updated: Feb. 2, 2011 - Peter W. Jansen
"""
if self.poa and (sens_mode.lower() == 'pgc'):
raise NotImplementedError("pySNOPT - Current implementation only "
"allows single level parallelization, "
"either 'POA' or 'pgc'")
if self.poa or (sens_mode.lower() == 'pgc'):
try:
import mpi4py
from mpi4py import MPI
except ImportError:
print('pySNOPT: Parallel objective Function Analysis '
'requires mpi4py')
comm = MPI.COMM_WORLD
nproc = comm.Get_size()
if mpi4py.__version__[0] == '0':
Bcast = comm.Bcast
# elif mpi4py.__version__[0] == '1':
else: # version can be 1, 2, 3 .... or more
Bcast = comm.bcast
self.pll = True
self.myrank = comm.Get_rank()
else:
self.pll = False
self.myrank = 0
myrank = self.myrank
def_fname = self.options['Print file'][1].split('.')[0]
hos_file, log_file, tmp_file = self._setHistory(
opt_problem.name, store_hst, hot_start, def_fname)
gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step,
*args, **kwargs)
# ======================================================================
# SNOPT-C - Objective/Constraint Values Function
# ======================================================================
def snfuncgrag(mode, njac, x, f_obj, g_obj, f_con, g_con):
# Variables Groups Handling
if opt_problem.use_groups:
xg = {}
for group in group_ids.keys():
if group_ids[group][1] - group_ids[group][0] == 1:
xg[group] = x[group_ids[group][0]]
else:
xg[group] = x[group_ids[group][0]:group_ids[group][1]]
xn = xg
else:
xn = x
# Flush Output Files
self.flushFiles()
# Evaluate User Function
fail = 0
if myrank == 0:
if self.h_start:
[vals,
hist_end] = hos_file.read(ident=['obj', 'con', 'fail'])
if hist_end:
self.h_start = False
hos_file.close()
else:
[f_obj, f_con, fail] = [
vals['obj'][0][0], vals['con'][0],
int(vals['fail'][0][0])
]
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[f_obj, f_con, fail] = Bcast([f_obj, f_con, fail], root=0)
elif not self.h_start:
[f_obj, f_con, fail] = opt_problem.obj_fun(xn, *args, **kwargs)
# Store History
if myrank == 0:
if self.sto_hst:
log_file.write(x, 'x')
log_file.write(f_obj, 'obj')
log_file.write(f_con, 'con')
log_file.write(fail, 'fail')
if fail == 1:
mode = -1
return mode
# Gradients
if mode != 0 and self.h_start:
if myrank == 0:
[vals,
hist_end] = hos_file.read(ident=['grad_obj', 'grad_con'])
if hist_end:
self.h_start = False
hos_file.close()
else:
g_obj = vals['grad_obj'][0]
g_con = vals['grad_con'][0].reshape(
(len(opt_problem.constraints.keys()),
len(opt_problem.variables.keys())))
if self.pll:
self.h_start = Bcast(self.h_start, root=0)
if self.h_start and self.pll:
[g_obj, g_con] = Bcast([g_obj, g_con], root=0)
if mode != 0 and not self.h_start:
dff, dgg = gradient.getGrad(x, group_ids, [f_obj], f_con,
*args, **kwargs)
for i in range(len(opt_problem.variables.keys())):
g_obj[i] = dff[0, i]
for j in range(len(opt_problem.constraints.keys())):
g_con[j, i] = dgg[j, i]
if myrank == 0:
if mode != 0 and self.sto_hst:
log_file.write(g_obj, 'grad_obj')
log_file.write(g_con, 'grad_con')
# Objective Assignment
if isinstance(f_obj, complex):
f_obj = f_obj.astype(float)
# Constraints Assignment
for i in range(len(opt_problem.constraints.keys())):
if isinstance(f_con[i], complex):
f_con[i] = f_con[i].astype(float)
if not f_con:
f_con = [0]
return mode, f_obj, g_obj, f_con, g_con
# Variables Handling
nvar = len(opt_problem.variables.keys())
blx = []
bux = []
xs = []
for key in opt_problem.variables.keys():
if opt_problem.variables[key].type == 'c':
blx.append(opt_problem.variables[key].lower)
bux.append(opt_problem.variables[key].upper)
xs.append(opt_problem.variables[key].value)
elif opt_problem.variables[key].type == 'i':
raise IOError('SNOPT cannot handle integer design variables')
elif opt_problem.variables[key].type == 'd':
raise IOError('SNOPT cannot handle discrete design variables')
blx = numpy.array(blx)
bux = numpy.array(bux)
xs = numpy.array(xs)
# Variables Groups Handling
group_ids = {}
if opt_problem.use_groups:
k = 0
for key in opt_problem.vargroups.keys():
group_len = len(opt_problem.vargroups[key]['ids'])
group_ids[opt_problem.vargroups[key]['name']] = [
k, k + group_len
]
k += group_len
# Constraints Handling
ncon = len(opt_problem.constraints.keys())
blc = []
buc = []
if ncon > 0:
for key in opt_problem.constraints.keys():
if opt_problem.constraints[key].type == 'e':
blc.append(opt_problem.constraints[key].equal)
buc.append(opt_problem.constraints[key].equal)
elif opt_problem.constraints[key].type == 'i':
blc.append(opt_problem.constraints[key].lower)
buc.append(opt_problem.constraints[key].upper)
else:
# if ((store_sol) and (myrank == 0)):
# print "Optimization Problem Does Not Have Constraints\n"
# print "Unconstrained Optimization Initiated\n"
ncon = 1
blc.append(-inf)
buc.append(inf)
blc = numpy.array(blc)
buc = numpy.array(buc)
# Objective Handling
objfunc = opt_problem.obj_fun
nobj = len(opt_problem.objectives.keys())
ff = []
for key in opt_problem.objectives.keys():
ff.append(opt_problem.objectives[key].value)
ff = numpy.array(ff, numpy.float)
# Initialize SNOPT
iPrint = self.options['iPrint'][1]
if myrank != 0:
iPrint = 0
PrintFile = self.options['Print file'][1]
if iPrint != 0:
if os.path.isfile(PrintFile):
os.remove(PrintFile)
ierror = snopt.openunit(iPrint, numpy.array(PrintFile),
numpy.array('new'),
numpy.array('sequential'))
if ierror != 0:
raise IOError('Failed to properly open %s, ierror = %3d' %
(PrintFile, ierror))
iSumm = self.options['iSumm'][1]
if myrank != 0:
iSumm = 0
SummFile = self.options['Summary file'][1]
if iSumm != 0:
if os.path.isfile(SummFile):
os.remove(SummFile)
ierror = snopt.openunit(iSumm, numpy.array(SummFile),
numpy.array('new'),
numpy.array('sequential'))
if ierror != 0:
raise IOError('Failed to properly open %s, ierror = %3d' %
(SummFile, ierror))
lencw = 500
leniw = 500 + 100 * (ncon + nvar)
lenrw = 500 + 200 * (ncon + nvar)
self.options['Total integer workspace'][1] = leniw
self.options['Total real workspace'][1] = lenrw
string = []
for i in range(lencw):
string.append(' ')
cw = numpy.array(string, 'c')
iw = numpy.zeros(leniw, 'i')
rw = numpy.zeros(lenrw, numpy.float)
snopt.sninit(iPrint, iSumm, cw, iw, rw)
# Memory allocation
ne = ncon * nvar
nnCon = numpy.array(ncon, numpy.int)
nnObj = numpy.array(nvar, numpy.int)
nnJac = numpy.array(nvar, numpy.int)
neGcon = nnCon * nnJac
iExit = 0
mincw, miniw, minrw, cw = snopt.snmemb(iExit, ncon, nvar, ne, neGcon,
nnCon, nnJac, nnObj, cw, iw, rw)
if (minrw > lenrw) or (miniw > leniw) or (mincw > lencw):
if mincw > lencw:
lencw = mincw
string = ""
for i in range(lencw):
string += " "
cw = numpy.transpose(
numpy.reshape(numpy.array(string), (lencw, 8)))
if miniw > leniw:
leniw = miniw
iw = numpy.zeros(leniw, 'i')
if minrw > lenrw:
lenrw = minrw
rw = numpy.zeros(lenrw, numpy.float)
snopt.sninit(iPrint, iSumm, cw, iw, rw)
# Set Options
inform = numpy.array([-1], numpy.int)
for i in range(len(self.set_options)):
name = self.set_options[i][0]
value = self.set_options[i][1]
if isinstance(value, str):
if name == 'Start':
if value == 'Cold':
snopt.snset('Cold start', iPrint, iSumm, inform, cw,
iw, rw)
elif value == 'Warm':
snopt.snset('Warm start', iPrint, iSumm, inform, cw,
iw, rw)
elif name == 'Problem Type':
if value == 'Minimize':
snopt.snset('Minimize', iPrint, iSumm, inform, cw, iw,
rw)
elif value == 'Maximize':
snopt.snset('Maximize', iPrint, iSumm, inform, cw, iw,
rw)
elif value == 'Feasible point':
snopt.snset('Feasible point', iPrint, iSumm, inform,
cw, iw, rw)
elif name == 'Print file':
snopt.snset(name + ' ' + '%d' % iPrint, iPrint, iSumm,
inform, cw, iw, rw)
elif name == 'Summary file':
snopt.snset(name + ' ' + '%d' % iSumm, iPrint, iSumm,
inform, cw, iw, rw)
else:
snopt.snset(name + ' ' + value, iPrint, iSumm, inform, cw,
iw, rw)
elif isinstance(value, float):
snopt.snsetr(name, value, iPrint, iSumm, inform, cw, iw, rw)
elif isinstance(value, int):
if (name == 'iPrint') and iPrint == 0:
pass
elif (name == 'iSumm') and iSumm == 0:
pass
else:
snopt.snseti(name, value, iPrint, iSumm, inform, cw, iw,
rw)
elif isinstance(value, type(None)):
snopt.snset(name, iPrint, iSumm, inform, cw, iw, rw)
# Setup argument list values
start = numpy.array(self.options['Start'][1])
nName = numpy.array([1], numpy.int)
nnCon = numpy.array(ncon, numpy.int)
nnObj = numpy.array(nvar, numpy.int)
nnJac = numpy.array(nvar, numpy.int)
iObj = numpy.array([0], numpy.int)
ObjAdd = numpy.array([0.], numpy.float)
ProbNm = numpy.array(self.name)
a = numpy.zeros(ne, numpy.float)
ha = numpy.zeros(ne, 'i')
ine = 0
for j in range(nvar):
for i in range(ncon):
ha[ine] = i + 1
ine += 1
ka = numpy.zeros(nvar + 1, 'i')
ka[0] = 1
for i in range(1, nvar + 1):
ka[i] = ka[i - 1] + ncon
xs = numpy.concatenate((xs, numpy.zeros(ncon, numpy.float)))
bl = numpy.concatenate((blx, blc))
bu = numpy.concatenate((bux, buc))
lencu = numpy.array([1], numpy.int)
leniu = numpy.array([1], numpy.int)
lenru = numpy.array([1], numpy.int)
cu = numpy.array([" "], 'c')
iu = numpy.zeros([leniu[0]], numpy.int)
ru = numpy.zeros([lenru[0]], numpy.float)
hs = numpy.zeros(nvar + ncon, 'i')
Names = numpy.array([" "], 'c')
pi = numpy.zeros(ncon, numpy.float)
rc = numpy.zeros(nvar + ncon, numpy.float)
# inform = numpy.array([-1], numpy.int)
mincw = numpy.array([0], numpy.int)
miniw = numpy.array([0], numpy.int)
minrw = numpy.array([0], numpy.int)
nS = numpy.array([0], numpy.int)
ninf = numpy.array([0], numpy.int)
sinf = numpy.array([0.], numpy.float)
# Run SNOPT
t0 = time.time()
snopt.snoptc(start, nnCon, nnObj, nnJac, iObj, ObjAdd, ProbNm,
snfuncgrag, a, ha, ka, bl, bu, Names, hs, xs, pi, rc,
inform, mincw, miniw, minrw, nS, ninf, sinf, ff, cu, iu,
ru, cw, iw, rw)
sol_time = time.time() - t0
if myrank == 0:
if self.sto_hst:
log_file.close()
if tmp_file:
hos_file.close()
name = hos_file.filename
os.remove(name + '.cue')
os.remove(name + '.bin')
os.rename(name + '_tmp.cue', name + '.cue')
os.rename(name + '_tmp.bin', name + '.bin')
if iPrint != 0:
snopt.closeunit(self.options['iPrint'][1])
if iSumm != 0:
snopt.closeunit(self.options['iSumm'][1])
# Store Results
sol_inform = {}
sol_inform['value'] = inform
sol_inform['text'] = self.getInform(inform)
if store_sol:
sol_name = 'SNOPT Solution to ' + opt_problem.name
sol_options = copy.copy(self.options)
# if sol_options.has_key('defaults'):
if 'defaults' in sol_options:
del sol_options['defaults']
sol_evals = 0
sol_vars = copy.deepcopy(opt_problem.variables)
i = 0
for key in sol_vars.keys():
sol_vars[key].value = xs[i]
i += 1
sol_objs = copy.deepcopy(opt_problem.objectives)
i = 0
for key in sol_objs.keys():
sol_objs[key].value = ff[i]
i += 1
sol_cons = copy.deepcopy(opt_problem.constraints)
i = 0
for key in sol_cons.keys():
sol_cons[key].value = xs[nvar + i]
i += 1
if ncon > 0:
sol_lambda = numpy.zeros(ncon, float)
for i in range(ncon):
sol_lambda[i] = pi[i]
else:
sol_lambda = {}
opt_problem.addSol(self.__class__.__name__,
sol_name,
objfunc,
sol_time,
sol_evals,
sol_inform,
sol_vars,
sol_objs,
sol_cons,
sol_options,
display_opts=disp_opts,
Lambda=sol_lambda,
Sensitivities=sens_type,
myrank=myrank,
arguments=args,
**kwargs)
return ff, xs[0:nvar], sol_inform