def solveOpt(int_domain,J,x,model,u0):
def objfun(u,**kwargs):
# 1) extract paraeters
int_domain = kwargs['int_domain']
J = kwargs['J']
x = kwargs['x']
model = kwargs['model']
# 2) define objective function
f = np.trapz(int_domain,J * model.pf(int_domain,u,x))
g = [0]*2
# 3) budget constraint
g[1] = u.sum() - 1
# 4) VaR constarint
W = model.W
sigmaMax = model.VaR / norm.ppf(1-model.alpha)
g[0] = -sigmaMax + np.sqrt(W.dot(u).dot(u))
fail = 0
return f,g,fail
opt_prob = Optimization('test problem',objfun)
opt_prob.addObj('f')
opt_prob.addCon('budget const','e')
opt_prob.addCon('VaR const','i')
opt_prob.addVarGroup('u',model.M,'c',lower=np.zeros(model.M),
upper=np.ones(model.M),value=u0)
print opt_prob
slsqp = SLSQP()
slsqp.setOption('IPRINT',-1)
slsqp(opt_prob,sens_type='FD',int_domain=int_domain,J=J,x=x,model=model)
print opt_prob.solution(0)
def solveOpt(int_domain, J, a, model, u0, sign):
'''
INPUT:
int_domain =
J =
a =
model =
u0 =
sign =
OUTPUT:
opt_prob =
'''
def objfun(u, **kwargs):
'''objfun defines the objective function and the constraints (equality
and inequality) of the optiization problem'''
# 1) extract paraeters
int_domain = kwargs['int_domain']
J = kwargs['J']
x = kwargs['a']
model = kwargs['model']
sign = kwargs['sign']
# 2) define objective function
funz = np.trapz(x=int_domain, y=J * model.pf(int_domain, u, x))
g = [0] * 2
# 3) budget constraint
g[0] = u.sum() - 1
# 4) VaR constarint
W = model.W
sigmaMax = model.VaR / norm.ppf(1 - model.alpha)
g[1] = -sigmaMax + np.sqrt(W.dot(u).dot(u))
fail = 0
return sign * funz, g, fail
opt_prob = Optimization('ODAA problem', objfun)
opt_prob.addObj('funz')
opt_prob.addCon('budget const', 'e')
opt_prob.addCon('VaR const', 'i')
slsqp = SLSQP() # instantiate Optimizer
slsqp.setOption('IPRINT', -1)
opt_prob.addVarGroup('u',
model.M,
'c',
lower=np.zeros(model.M),
upper=np.ones(model.M),
value=u0)
#print opt_prob # print optimization problem
slsqp(opt_prob,
sens_type='FD',
int_domain=int_domain,
J=J,
a=a,
model=model,
sign=sign)
#print opt_prob.solution(0) # print solution
return opt_prob
def optimize(k, w1, w2):
# Physical problem
rho = 0.2836 # lb/in^3
L = 5.0 # in
P = 25000.0 # lb
E = 30.0e6 # psi
ys = 36260.0 # psi
fs = 1.5
dtruss = TwoBarTruss(rho, L, P, E, ys, fs)
struss = StochasticTwoBarTruss(dtruss)
# Optimization Problem
optproblem = TwoBarTrussOpt(MPI.COMM_WORLD, struss, k, w1, w2)
opt_prob = Optimization(args.logfile, optproblem.evalObjCon)
# Add functions
opt_prob.addObj('weight')
opt_prob.addCon('buckling-bar1', type='i')
opt_prob.addCon('failure-bar1' , type='i')
opt_prob.addCon('failure-bar2' , type='i')
# Add variables
opt_prob.addVar('area-1', type='c', value= 1.5, lower= 1.5, upper= 1.5)
opt_prob.addVar('area-2', type='c', value= 1.5, lower= 1.5, upper= 1.5)
opt_prob.addVar('height', type='c', value= 4.0, lower= 4.0, upper= 10.0)
# Optimization algorithm
if args.algorithm == 'ALGENCAN':
opt = ALGENCAN()
opt.setOption('iprint',2)
opt.setOption('epsfeas',1e-6)
opt.setOption('epsopt',1e-6)
else:
opt = SLSQP(pll_type='POA')
opt.setOption('MAXIT',999)
opt(opt_prob,
sens_type=optproblem.evalObjConGradient,
disp_opts=True,
store_hst=True,
hot_start=False)
if optproblem.comm.Get_rank() ==0:
print opt_prob.solution(0)
opt_prob.write2file(disp_sols=True)
x = optproblem.x_hist[-1]
f = optproblem.fvals[0]
print 'x', x
print 'f', f
return x, f
def train(self, optimizer='pso'):
#Define the optimization problem for training the kriging model
opt_prob = Optimization('Surrogate Test', self.fittingObjective)
for i in range(self.k):
opt_prob.addVar('theta%d' % i,
'c',
lower=1e-3,
upper=1e2,
value=.1)
for i in range(self.k):
opt_prob.addVar('pl%d' % i, 'c', lower=1.5, upper=2, value=2)
opt_prob.addVar('lambda', 'c', lower=1e-5, upper=1, value=1)
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
if optimizer == 'pso':
optimizer = ALPSO()
optimizer.setOption('SwarmSize', 150)
optimizer.setOption('maxOuterIter', 150)
optimizer.setOption('stopCriteria', 1)
optimizer.setOption('filename', '{0}Results.log'.format(self.name))
if optimizer == 'ga':
optimizer = NSGA2()
optimizer.setOption('PopSize', (4 * 50))
while True:
try:
self.trainingOptimizer(optimizer, opt_prob)
except Exception as e:
print e
print 'Error traning Model, restarting the optimizer with a larger population'
if optimizer == 'ga':
optimizer.setOption('SwarmSize', 200)
optimizer.setOption('maxOuterIter', 100)
optimizer.setOption('stopCriteria', 1)
if optimizer == 'ga':
optimizer.setOption('PopSize', 400)
else:
break
return f, g, fail
opt_prob = Optimization('TP37 Constrained Problem', objfunc)
for i in range(1, len(CONS_LHS_MIN_1_php) + 1):
x_value = 'x' + str(i)
opt_prob.addVar(x_value,
'c',
lower=float(CONS_LHS_MIN_1_php[i - 1]),
upper=float(CONS_RHS_MAX_1_php[i - 1]),
value=1)
opt_prob.addObj('f')
for i in range(1, len(NUTRIENTS_php) * 2 + 1):
g_value = 'g' + str(i)
opt_prob.addCon(g_value, 'i')
# Instantiate Optimizer (SLSQP)
slsqp = SLSQP()
slsqp.setOption('IPRINT', 2)
# Solve Problem (Without Parallel Gradient)
[fstr, xstr, inform] = slsqp(opt_prob, sens_type='CS')
if myrank == 0:
sol = opt_prob.solution(0)
#end
xstr_array = []
for element in xstr:
element = decimal.Decimal(element)
xstr_array.append(round(element, 4))
return dareadx
################################################################################
dp = crm_togw()
design_problem = PyOptOptimization(dp.comm,
dp.eval_objcon,
dp.eval_objcon_grad,
number_of_steps=3)
opt_prob = Optimization('crm_togw', design_problem.eval_obj_con)
opt_prob.addObj('TOGW')
opt_prob.addCon('cruise_lift', type='e')
opt_prob.addCon('maneuver_lift', type='e')
opt_prob.addCon('area', type='e')
opt_prob.addCon('ksfailure', type='i')
for i in range(187 - 3):
opt_prob.addCon('Smoothness %i a' % i, type='i')
opt_prob.addCon('Smoothness %i b' % i, type='i')
variables = dp.model.get_variables()
for i, var in enumerate(variables):
print('i', i)
opt_prob.addVar(var.name,
type='c',
value=var.value / dp.var_scale[i],
class SLSQP_pyOpt(Algorithm):
""" Utilization of the SLSQP algorithm of pyOpt package."""
def __init__(self):
"""Initialize the SLSQP algorithm for a specific building.
"""
print("Initializing the SLSQP Optimizer...")
self.opt_prob = []
self.opt = []
self.building = Building()
def configure(self, building):
# Get building and optimization setup properties
self.building = deepcopy(building)
self.T, self.states, self.actions, self.disturbances, self.controlLim, self.actionLim, self.comfort, self.occ, self.nvars, self.ncons = self.building.getConfiguration(
)
# Define Box Constraints (min/max values) for the control parameters
boxConstraints = []
for ii in range(self.nvars):
boxConstraints.append(self.controlLim)
# Link to the python function calculating the cost and the constraints
self.opt_prob = Optimization('SLSQP Constrained Problem',
self.wrapSimulation)
# Setupt Box Constrains in pyOpt
for ii in range(self.nvars):
self.opt_prob.addVar('x' + str(ii + 1),
'c',
lower=boxConstraints[ii][0],
upper=boxConstraints[ii][1],
value=self.building.policy[0, ii])
# Setupt Cost Function in pyOpt
self.opt_prob.addObj('f')
# Setupt Inequality Constraints in pyOpt
for ii in range(self.ncons):
self.opt_prob.addCon('g' + str(ii + 1), 'i')
# Print the Optimization setup
print("----------------------------------------")
print("----------------------------------------")
print("SLSQP Optimization setup:")
print(self.opt_prob)
def optimize(self, options=[]):
# Set SLSQP as the optimizer
self.opt = SLSQP()
# Set optimization options
if (len(options) > 0):
for ii in range(len(options)):
self.opt.setOption(options.keys()[ii], options.values()[ii])
# Print the Optimizer Options
print("----------------------------------------")
print("----------------------------------------")
print("SLSQP Optimizer options:")
print(self.opt.options)
# Get optimized controller
self.opt(self.opt_prob, sens_step=1e-6)
print(self.opt_prob.solution(0))
a = self.opt_prob.solution(0)
for ii in range(self.building.policy.shape[1]):
self.building.policy[0, ii] = a.getVar(ii).value
return self.building.policy
def wrapSimulation(self, policy):
"""A function that runs a building simulation and wraps the results in the
format required by PyOpt library.
Args:
policy (numpy array): the controller to be used for the simulation
Returns:
f (float): the cost function value
g (list): the vales of all constraints
fail (0/1): indicates if the function finished successfully
"""
# Cost and Constraints
f = 0
g = []
fail = 0
# Run building simulation
x, cost, constraints = self.building.simulate(policy)
f = np.sum(cost)
g.append(np.sum(constraints))
# print(f)
# print(g[0])
return f, g, fail
(x[1] - b[i])**2)))
#end
g = [0.0] * 1
g[0] = 20.04895 - (x[0] + 2.0)**2 - (x[1] + 1.0)**2
fail = 0
return f, g, fail
# =============================================================================
#
# =============================================================================
opt_prob = Optimization('Langermann Function 11', objfunc)
opt_prob.addVar('x1', 'c', lower=-2.0, upper=10.0, value=8.0)
opt_prob.addVar('x2', 'c', lower=-2.0, upper=10.0, value=8.0)
opt_prob.addObj('f')
opt_prob.addCon('g', 'i')
print(opt_prob)
# Global Optimization
nsga2 = NSGA2()
nsga2(opt_prob)
print(opt_prob.solution(0))
# Local Optimization Refinement
slsqp = SLSQP()
slsqp(opt_prob.solution(0))
print(opt_prob.solution(0).solution(0))
return g_obj, g_con, fail
# =============================================================================
#
# =============================================================================
# Instantiate Optimization Problem
opt_prob = Optimization('Constrained Rosen-Suzuki', objfunc)
opt_prob.addVar('x1', 'c', value=1.5)
opt_prob.addVar('x2', 'c', value=1.5)
opt_prob.addVar('x3', 'c', value=1.5)
opt_prob.addVar('x4', 'c', value=1.5)
opt_prob.addObj('f')
opt_prob.addCon('g1', 'i')
opt_prob.addCon('g2', 'i')
opt_prob.addCon('g3', 'i')
print opt_prob
# Instantiate Optimizer (CONMIN)
conmin = CONMIN()
# Solve Problem with Optimizer Using Finite Differences
conmin(opt_prob, sens_type='FD')
print opt_prob.solution(0)
# Solve Problem with Optimizer Using Complex Step
#conmin(opt_prob,sens_type='CS')
#print opt_prob.solution(1)
def main():
###########################################
# Define some values
###########################################
n_blades = 2
n_elements = 10
radius = unit_conversion.in2m(9.6) / 2
root_cutout = 0.1 * radius
dy = float(radius - root_cutout) / n_elements
dr = float(1) / n_elements
y = root_cutout + dy * np.arange(1, n_elements + 1)
r = y / radius
pitch = 0.0
airfoils = (('SDA1075_494p', 0.0, 1.0), )
#allowable_Re = []
allowable_Re = [
1000000., 500000., 250000., 100000., 90000., 80000., 70000., 60000.,
50000., 40000., 30000., 20000., 10000.
]
vehicle_weight = 12.455
max_chord = 0.6
max_chord_tip = 5.
alt = 0
tip_loss = True
mach_corr = False
# Forward flight parameters
v_inf = 4. # m/s
alpha0 = 0.0454 # Starting guess for trimmed alpha in radians
n_azi_elements = 5
# Mission times
time_in_hover = 0. # Time in seconds
time_in_ff = 500.
mission_time = [time_in_hover, time_in_ff]
Cl_tables = {}
Cd_tables = {}
Clmax = {}
# Get lookup tables
if any(airfoil[0] != 'simple' for airfoil in airfoils):
for airfoil in airfoils:
Cl_table, Cd_table, Clmax = aero_coeffs.create_Cl_Cd_table(
airfoil[0])
Cl_tables[airfoil[0]] = Cl_table
Cd_tables[airfoil[0]] = Cd_table
Clmax[airfoil[0]] = Clmax
# Create list of Cl functions. One for each Reynolds number. Cl_tables (and Cd_tables) will be empty for the
# 'simple' case, therefore this will be skipped for the simple case. For the full table lookup case this will be
# skipped because allowable_Re will be empty.
Cl_funs = {}
Cd_funs = {}
lift_curve_info_dict = {}
if Cl_tables and allowable_Re:
Cl_funs = dict(
zip(allowable_Re, [
aero_coeffs.get_Cl_fun(Re, Cl_tables[airfoils[0][0]],
Clmax[airfoils[0][0]][Re])
for Re in allowable_Re
]))
Cd_funs = dict(
zip(allowable_Re, [
aero_coeffs.get_Cd_fun(Re, Cd_tables[airfoils[0][0]])
for Re in allowable_Re
]))
lift_curve_info_dict = aero_coeffs.create_liftCurveInfoDict(
allowable_Re, Cl_tables[airfoils[0][0]])
###########################################
# Set design variable bounds
###########################################
omega_start = 4250. * 2 * np.pi / 60
# These are c/R values for the DA4002 propeller given at the UIUC propeller database
chord_base = np.array([
0.1198, 0.1128, 0.1436, 0.1689, 0.1775, 0.1782, 0.1773, 0.1782, 0.1790,
0.1787, 0.1787, 0.1786, 0.1785, 0.1790, 0.1792, 0.1792, 0.1692, 0.0154
])
chord_base = np.array(
[chord_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]])
twist_base = np.array([
42.481, 44.647, 41.154, 37.475, 34.027, 30.549, 27.875, 25.831, 23.996,
22.396, 21.009, 19.814, 18.786, 17.957, 17.245, 16.657, 13.973, 2.117
]) * 2 * np.pi / 360
twist_base = np.array(
[twist_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]])
dtwist_base = np.array([
twist_base[i + 1] - twist_base[i] for i in xrange(len(twist_base) - 1)
])
dchord_base = np.array([
chord_base[i + 1] - chord_base[i] for i in xrange(len(chord_base) - 1)
])
twist0_base = twist_base[0]
chord0_base = chord_base[0]
chord_start = chord_base
twist_start = twist_base
dtwist_start = dtwist_base
dchord_start = dchord_base
twist0_start = twist0_base
chord0_start = chord0_base
print "chord0_start = " + str(chord0_start)
omega_lower = 2000 * 2 * np.pi / 60
omega_upper = 8000.0 * 2 * np.pi / 60
twist0_lower = 0. * 2 * np.pi / 360
twist0_upper = 60. * 2 * np.pi / 360
chord0_upper = 0.1198
chord0_lower = 0.05
dtwist_lower = -10.0 * 2 * np.pi / 360
dtwist_upper = 10.0 * 2 * np.pi / 360
dchord_lower = -0.1
dchord_upper = 0.1
opt_prob = Optimization('Mission Simulator', objfun)
opt_prob.addVar('omega_h',
'c',
value=omega_start,
lower=omega_lower,
upper=omega_upper)
opt_prob.addVar('twist0',
'c',
value=twist0_start,
lower=twist0_lower,
upper=twist0_upper)
opt_prob.addVar('chord0',
'c',
value=chord0_start,
lower=chord0_lower,
upper=chord0_upper)
opt_prob.addVarGroup('dtwist',
n_elements - 1,
'c',
value=dtwist_start,
lower=dtwist_lower,
upper=dtwist_upper)
opt_prob.addVarGroup('dchord',
n_elements - 1,
'c',
value=dchord_start,
lower=dchord_lower,
upper=dchord_upper)
opt_prob.addObj('f')
opt_prob.addCon('thrust', 'i')
opt_prob.addCon('c_tip', 'i')
opt_prob.addConGroup('c_lower', n_elements, 'i')
opt_prob.addConGroup('c_upper', n_elements, 'i')
print opt_prob
pop_size = 300
max_gen = 1100
opt_method = 'nograd'
nsga2 = NSGA2()
nsga2.setOption('PrintOut', 2)
nsga2.setOption('PopSize', pop_size)
nsga2.setOption('maxGen', max_gen)
nsga2.setOption('pCross_real', 0.85)
nsga2.setOption('pMut_real', 0.2)
nsga2.setOption('xinit', 1)
fstr, xstr, inform = nsga2(opt_prob,
n_blades=n_blades,
radius=radius,
dy=dy,
dr=dr,
y=y,
r=r,
pitch=pitch,
airfoils=airfoils,
vehicle_weight=vehicle_weight,
max_chord=max_chord,
tip_loss=tip_loss,
mach_corr=mach_corr,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
Cl_tables=Cl_tables,
Cd_tables=Cd_tables,
allowable_Re=allowable_Re,
opt_method=opt_method,
alt=alt,
v_inf=v_inf,
alpha0=alpha0,
mission_time=mission_time,
n_azi_elements=n_azi_elements,
pop_size=pop_size,
max_gen=max_gen,
lift_curve_info_dict=lift_curve_info_dict,
max_chord_tip=max_chord_tip)
print opt_prob.solution(0)
# opt_method = 'nograd'
# xstart_alpso = np.concatenate((np.array([omega_start, twist0_start, chord0_start]), dtwist_start, dchord_start))
# alpso = ALPSO()
# alpso.setOption('xinit', 0)
# alpso.setOption('SwarmSize', 200)
# alpso.setOption('maxOuterIter', 100)
# alpso.setOption('stopCriteria', 0)
# fstr, xstr, inform = alpso(opt_prob, xstart=xstart_alpso, n_blades=n_blades, n_elements=n_elements,
# root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch,
# airfoils=airfoils, thrust=thrust, max_chord=max_chord, tip_loss=tip_loss,
# mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables,
# Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method)
# print opt_prob.solution(0)
# opt_method = 'grad'
# slsqp = SLSQP()
# slsqp.setOption('IPRINT', 1)
# slsqp.setOption('MAXIT', 1000)
# slsqp.setOption('ACC', 1e-7)
# fstr, xstr, inform = slsqp(opt_prob, sens_type='FD', n_blades=n_blades, n_elements=n_elements,
# root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch,
# airfoils=airfoils, thrust=thrust, max_chord=max_chord,
# tip_loss=tip_loss, mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs,
# Cl_tables=Cl_tables, Cd_tables=Cd_tables, allowable_Re=allowable_Re,
# opt_method=opt_method, alt=alt)
# print opt_prob.solution(0)
def get_performance(o, c, t):
chord_meters = c * radius
prop = propeller.Propeller(t,
chord_meters,
radius,
n_blades,
r,
y,
dr,
dy,
airfoils=airfoils,
Cl_tables=Cl_tables,
Cd_tables=Cd_tables)
quad = quadrotor.Quadrotor(prop, vehicle_weight)
ff_kwargs = {
'propeller': prop,
'pitch': pitch,
'n_azi_elements': n_azi_elements,
'allowable_Re': allowable_Re,
'Cl_funs': Cl_funs,
'Cd_funs': Cd_funs,
'tip_loss': tip_loss,
'mach_corr': mach_corr,
'alt': alt,
'lift_curve_info_dict': lift_curve_info_dict
}
trim0 = np.array([alpha0, o])
alpha_trim, omega_trim, converged = trim.trim(quad, v_inf, trim0,
ff_kwargs)
T_ff, H_ff, P_ff = bemt.bemt_forward_flight(
quad,
pitch,
omega_trim,
alpha_trim,
v_inf,
n_azi_elements,
alt=alt,
tip_loss=tip_loss,
mach_corr=mach_corr,
allowable_Re=allowable_Re,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
lift_curve_info_dict=lift_curve_info_dict)
dT_h, P_h = bemt.bemt_axial(prop,
pitch,
o,
allowable_Re=allowable_Re,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
tip_loss=tip_loss,
mach_corr=mach_corr,
alt=alt)
return sum(dT_h), P_h, T_ff, P_ff, alpha_trim, omega_trim
omega = xstr[0]
twist0 = xstr[1]
chord0 = xstr[2]
dtwist = xstr[3:3 + len(r) - 1]
dchord = xstr[3 + len(r) - 1:]
twist = calc_twist_dist(twist0, dtwist)
chord = calc_chord_dist(chord0, dchord)
print "chord = " + repr(chord)
print "twist = " + repr(twist)
# twist_base = calc_twist_dist(twist0_base, dtwist_base)
# chord_base = calc_chord_dist(chord0_base, dchord_base)
perf_opt = get_performance(omega, chord, twist)
#perf_base = get_performance(omega_start, chord_base, twist_base)
print "omega = " + str(omega * 60 / 2 / np.pi)
print "Hover Thrust of optimized = " + str(perf_opt[0])
print "Hover Power of optimized = " + str(perf_opt[1])
print "FF Thrust of optimized = " + str(perf_opt[2])
print "FF Power of optimized = " + str(perf_opt[3])
print "Trim (alpha, omega) = (%f, %f)" % (perf_opt[4], perf_opt[5])
return -sum([
x[i] * sum([(1 + len(reachable_sets[i][u])) * y[i][u] - 0.5 * sum([
len(set(reachable_sets[i][u]) & set(reachable_sets[i][v])) *
y[i][u] * y[i][v] for v in users if v != u
]) for u in users]) for i in items
]), g, fail
#return -np.dot(x,(((1+reachable_sets_len)*y).sum(axis=1) - 0.5*(y*((y[:,:,None]*intersections).sum(axis=2))).sum(axis=1)))
# Initialize problem
opt_prob = Optimization('Algorithm A: Real-valued Relaxation',
objective,
use_groups=True)
opt_prob.addVarGroup('x', len(x), 'c', lower=0.0, upper=1.0, value=0.5)
opt_prob.addVarGroup('y',
len(y.flatten()),
'c',
lower=0.0,
upper=1.0,
value=0.5)
opt_prob.addObj('f')
opt_prob.addCon('g0', 'e')
#opt_prob.addConGroup('g1',len(users),'i')
print(opt_prob)
# Instantiate Optimizer (SLSQP) & Solve Problem
slsqp = SLSQP()
slsqp.setOption('IPRINT', -1)
slsqp(opt_prob, sens_type='FD')
print(opt_prob.solution(0))
def main():
###########################################
# Define some values
###########################################
n_blades = 2
n_elements = 10
radius = unit_conversion.in2m(9.6) / 2
#radius = 0.1397
root_cutout = 0.1 * radius
dy = float(radius - root_cutout) / n_elements
dr = float(1) / n_elements
y = root_cutout + dy * np.arange(1, n_elements + 1)
r = y / radius
pitch = 0.0
airfoils = (('SDA1075_494p', 0.0, 1.0), )
#allowable_Re = []
allowable_Re = [
1000000., 500000., 250000., 100000., 90000., 80000., 70000., 60000.,
50000., 40000., 30000., 20000., 10000.
]
vehicle_weight = 12.455
max_chord = 0.6
alt = 0
tip_loss = True
mach_corr = False
Cl_tables = {}
Cd_tables = {}
Clmax = {}
# Get lookup tables
if any(airfoil[0] != 'simple' for airfoil in airfoils):
for airfoil in airfoils:
Cl_table, Cd_table, Clmax = aero_coeffs.create_Cl_Cd_table(
airfoil[0])
Cl_tables[airfoil[0]] = Cl_table
Cd_tables[airfoil[0]] = Cd_table
Clmax[airfoil[0]] = Clmax
# Create list of Cl functions. One for each Reynolds number. Cl_tables (and Cd_tables) will be empty for the
# 'simple' case, therefore this will be skipped for the simple case. For the full table lookup case this will be
# skipped because allowable_Re will be empty.
Cl_funs = {}
Cd_funs = {}
lift_curve_info_dict = {}
if Cl_tables and allowable_Re:
Cl_funs = dict(
zip(allowable_Re, [
aero_coeffs.get_Cl_fun(Re, Cl_tables[airfoils[0][0]],
Clmax[airfoils[0][0]][Re])
for Re in allowable_Re
]))
Cd_funs = dict(
zip(allowable_Re, [
aero_coeffs.get_Cd_fun(Re, Cd_tables[airfoils[0][0]])
for Re in allowable_Re
]))
lift_curve_info_dict = aero_coeffs.create_liftCurveInfoDict(
allowable_Re, Cl_tables[airfoils[0][0]])
###########################################
# Set design variable bounds
###########################################
omega_start = 4250. * 2 * np.pi / 60
chord_base = np.array([
0.1198, 0.1128, 0.1436, 0.1689, 0.1775, 0.1782, 0.1773, 0.1782, 0.1790,
0.1787, 0.1787, 0.1786, 0.1785, 0.1790, 0.1792, 0.1792, 0.1692, 0.0154
])
chord_base = np.array(
[chord_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]])
twist_base = np.array([
42.481, 44.647, 41.154, 37.475, 34.027, 30.549, 27.875, 25.831, 23.996,
22.396, 21.009, 19.814, 18.786, 17.957, 17.245, 16.657, 13.973, 2.117
]) * 2 * np.pi / 360
twist_base = np.array(
[twist_base[i] for i in [0, 2, 4, 6, 8, 10, 12, 14, 15, 17]])
dtwist_base = np.array([
twist_base[i + 1] - twist_base[i] for i in xrange(len(twist_base) - 1)
])
dchord_base = np.array([
chord_base[i + 1] - chord_base[i] for i in xrange(len(chord_base) - 1)
])
twist0_base = twist_base[0]
chord0_base = chord_base[0]
chord_start = chord_base
twist_start = twist_base
dtwist_start = dtwist_base
dchord_start = dchord_base
twist0_start = twist0_base
chord0_start = chord0_base
# chord = np.array([8.92386048e-02, 1.73000845e-01, 2.70523039e-01, 2.71542807e-01, 2.78749355e-01, 2.36866151e-01,
# 2.04103526e-01, 1.37456074e-01, 8.68094589e-02, 1.05601135e-04])
# twist = np.array([0.00161645, 0.15105685, 0.28791442, 0.31577392, 0.28644651, 0.27418749, 0.24854514, 0.21812646,
# 0.19802027, 0.14972058])
# omega_start = 3184.41320387 * 2*np.pi/60
# chord_start = chord
# twist_start = twist
# dchord_start = np.array([chord[i+1]-chord[i] for i in xrange(len(chord)-1)])
# dtwist_start = np.array([twist[i+1]-twist[i] for i in xrange(len(twist)-1)])
# twist0_start = twist[0]
# chord0_start = chord[0]
## Initialize everything to zeros
# dtwist_start = np.zeros(n_elements-1)
# dchord_start = np.zeros(n_elements-1)
# twist0_start = 0.0
# chord0_start = 0.0
omega_lower = 2000 * 2 * np.pi / 60
omega_upper = 8000.0 * 2 * np.pi / 60
twist0_lower = 0.0 * 2 * np.pi / 360
twist0_upper = 60. * 2 * np.pi / 360
chord0_upper = 0.1198
chord0_lower = 0.05
dtwist_lower = -10.0 * 2 * np.pi / 360
dtwist_upper = 10.0 * 2 * np.pi / 360
dchord_lower = -0.1
dchord_upper = 0.1
opt_prob = Optimization('Rotor in Hover', objfun)
opt_prob.addVar('omega',
'c',
value=omega_start,
lower=omega_lower,
upper=omega_upper)
opt_prob.addVar('twist0',
'c',
value=twist0_start,
lower=twist0_lower,
upper=twist0_upper)
opt_prob.addVar('chord0',
'c',
value=chord0_start,
lower=chord0_lower,
upper=chord0_upper)
opt_prob.addVarGroup('dtwist',
n_elements - 1,
'c',
value=dtwist_start,
lower=dtwist_lower,
upper=dtwist_upper)
opt_prob.addVarGroup('dchord',
n_elements - 1,
'c',
value=dchord_start,
lower=dchord_lower,
upper=dchord_upper)
opt_prob.addObj('f')
opt_prob.addCon('thrust', 'i')
opt_prob.addConGroup('c_lower', n_elements, 'i')
opt_prob.addConGroup('c_upper', n_elements, 'i')
print opt_prob
opt_method = 'nograd'
nsga2 = NSGA2()
nsga2.setOption('PrintOut', 2)
nsga2.setOption('PopSize', 300)
nsga2.setOption('maxGen', 1100)
nsga2.setOption('pCross_real', 0.85)
nsga2.setOption('xinit', 1)
fstr, xstr, inform = nsga2(opt_prob,
n_blades=n_blades,
n_elements=n_elements,
root_cutout=root_cutout,
radius=radius,
dy=dy,
dr=dr,
y=y,
r=r,
pitch=pitch,
airfoils=airfoils,
vehicle_weight=vehicle_weight,
max_chord=max_chord,
tip_loss=tip_loss,
mach_corr=mach_corr,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
Cl_tables=Cl_tables,
Cd_tables=Cd_tables,
allowable_Re=allowable_Re,
opt_method=opt_method,
alt=alt,
lift_curve_info_dict=lift_curve_info_dict)
print opt_prob.solution(0)
# opt_method = 'nograd'
# xstart_alpso = np.concatenate((np.array([omega_start, twist0_start, chord0_start]), dtwist_start, dchord_start))
# alpso = ALPSO()
# alpso.setOption('xinit', 0)
# alpso.setOption('SwarmSize', 200)
# alpso.setOption('maxOuterIter', 100)
# alpso.setOption('stopCriteria', 0)
# fstr, xstr, inform = alpso(opt_prob, xstart=xstart_alpso, n_blades=n_blades, n_elements=n_elements,
# root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch,
# airfoils=airfoils, thrust=thrust, max_chord=max_chord, tip_loss=tip_loss,
# mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables,
# Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method)
# print opt_prob.solution(0)
# opt_method = 'grad'
# slsqp = SLSQP()
# slsqp.setOption('IPRINT', 1)
# slsqp.setOption('MAXIT', 1000)
# slsqp.setOption('ACC', 1e-7)
# fstr, xstr, inform = slsqp(opt_prob, sens_type='FD', n_blades=n_blades, n_elements=n_elements,
# root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch,
# airfoils=airfoils, thrust=thrust, max_chord=max_chord,
# tip_loss=tip_loss, mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs,
# Cl_tables=Cl_tables, Cd_tables=Cd_tables, allowable_Re=allowable_Re,
# opt_method=opt_method, alt=alt)
# print opt_prob.solution(0)
def get_performance(o, c, t):
chord_meters = c * radius
prop = propeller.Propeller(t,
chord_meters,
radius,
n_blades,
r,
y,
dr,
dy,
airfoils=airfoils,
Cl_tables=Cl_tables,
Cd_tables=Cd_tables)
return bemt.bemt_axial(prop,
pitch,
o,
allowable_Re=allowable_Re,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
tip_loss=tip_loss,
mach_corr=mach_corr,
output='long',
alt=alt)
omega = xstr[0]
twist0 = xstr[1]
chord0 = xstr[2]
dtwist = xstr[3:3 + len(r) - 1]
dchord = xstr[3 + len(r) - 1:]
twist = calc_twist_dist(twist0, dtwist)
chord = calc_chord_dist(chord0, dchord)
print "chord = " + repr(chord)
print "twist = " + repr(twist)
# twist_base = calc_twist_dist(twist0_base, dtwist_base)
# chord_base = calc_chord_dist(chord0_base, dchord_base)
perf_opt = get_performance(omega, chord, twist)
#perf_base = get_performance(omega_start, chord_base, twist_base)
print "omega = " + str(omega * 60 / 2 / np.pi)
print "Thrust of optimized = " + str(sum(perf_opt[0]))
print "Power of optimized = " + str(perf_opt[1])
# print "Omega base = " + str(omega_start*60/2/np.pi)
# print "Thrust of base = " + str(sum(perf_base[0]))
# print "Power of base = " + str(sum(perf_base[1]))
plt.figure(1)
plt.plot(r, chord_start, '-b')
plt.plot(r, chord, '-r')
plt.xlabel('radial location')
plt.ylabel('c/R')
plt.legend(['start', 'opt'])
plt.figure(2)
plt.plot(r, twist_start * 180 / np.pi, '-b')
plt.plot(r, twist * 180 / np.pi, '-r')
plt.xlabel('radial location')
plt.ylabel('twist')
plt.legend(['start', 'opt'])
plt.show()
def execute(self):
"""pyOpt execution. Note that pyOpt controls the execution, and the
individual optimizers control the iteration."""
self.pyOpt_solution = None
self.run_iteration()
opt_prob = Optimization(self.title, self.objfunc, var_set={},
obj_set={}, con_set={})
# Add all parameters
self.param_type = {}
self.nparam = self.total_parameters()
for name, param in self.get_parameters().iteritems():
# We need to identify Enums, Lists, Dicts
metadata = param.get_metadata()[1]
values = param.evaluate()
# Assuming uniform enumerated, discrete, or continuous for now.
val = values[0]
choices = []
if 'values' in metadata and \
isinstance(metadata['values'], (list, tuple, array, set)):
vartype = 'd'
choices = metadata['values']
elif isinstance(val, bool):
vartype = 'd'
choices = [True, False]
elif isinstance(val, (int, int32, int64)):
vartype = 'i'
elif isinstance(val, (float, float32, float64)):
vartype = 'c'
else:
msg = 'Only continuous, discrete, or enumerated variables' \
' are supported. %s is %s.' % (name, type(val))
self.raise_exception(msg, ValueError)
self.param_type[name] = vartype
names = param.names
lower_bounds = param.get_low()
upper_bounds = param.get_high()
for i in range(param.size):
opt_prob.addVar(names[i], vartype,
lower=lower_bounds[i], upper=upper_bounds[i],
value=values[i], choices=choices)
# Add all objectives
for name in self.get_objectives():
opt_prob.addObj(name)
# Add all equality constraints
for name, con in self.get_eq_constraints().items():
if con.size > 1:
for i in range(con.size):
opt_prob.addCon('%s [%s]' % (name, i), type='e')
else:
opt_prob.addCon(name, type='e')
# Add all inequality constraints
for name, con in self.get_ineq_constraints().items():
if con.size > 1:
for i in range(con.size):
opt_prob.addCon('%s [%s]' % (name, i), type='i')
else:
opt_prob.addCon(name, type='i')
self.inputs = self.list_param_group_targets()
self.objs = self.list_objective_targets()
self.cons = self.list_constraint_targets()
# Instantiate the requested optimizer
optimizer = self.optimizer
try:
exec('from pyOpt import %s' % optimizer)
except ImportError:
msg = "Optimizer %s is not available in this installation." % \
optimizer
self.raise_exception(msg, ImportError)
optname = vars()[optimizer]
opt = optname()
# Set optimization options
for option, value in self.options.iteritems():
opt.setOption(option, value)
# Execute the optimization problem
if self.pyopt_diff:
# Use pyOpt's internal finite difference
opt(opt_prob, sens_type='FD', sens_step=self.gradient_options.fd_step,
store_hst=self.store_hst, hot_start=self.hot_start)
else:
# Use OpenMDAO's differentiator for the gradient
opt(opt_prob, sens_type=self.gradfunc, store_hst=self.store_hst,
hot_start=self.hot_start)
# Print results
if self.print_results:
print opt_prob.solution(0)
# Pull optimal parameters back into framework and re-run, so that
# framework is left in the right final state
dvals = []
for i in range(0, len(opt_prob.solution(0)._variables)):
dvals.append(opt_prob.solution(0)._variables[i].value)
# Integer parameters come back as floats, so we need to round them
# and turn them into python integers before setting.
if 'i' in self.param_type.values():
for j, param in enumerate(self.get_parameters().keys()):
if self.param_type[param] == 'i':
dvals[j] = int(round(dvals[j]))
self.set_parameters(dvals)
self.run_iteration()
# Save the most recent solution.
self.pyOpt_solution = opt_prob.solution(0)
return g_obj, g_con, fail
# =============================================================================
#
# =============================================================================
# Instantiate Optimization Problem
opt_prob = Optimization("Constrained Rosen-Suzuki", objfunc)
opt_prob.addVar("x1", "c", value=1.5)
opt_prob.addVar("x2", "c", value=1.5)
opt_prob.addVar("x3", "c", value=1.5)
opt_prob.addVar("x4", "c", value=1.5)
opt_prob.addObj("f")
opt_prob.addCon("g1", "i")
opt_prob.addCon("g2", "i")
opt_prob.addCon("g3", "i")
print opt_prob
# Instantiate Optimizer (CONMIN)
conmin = CONMIN()
# Solve Problem with Optimizer Using Finite Differences
conmin(opt_prob, sens_type="FD")
print opt_prob.solution(0)
# Solve Problem with Optimizer Using Complex Step
conmin(opt_prob, sens_type="CS")
print opt_prob.solution(1)
def execute(self):
"""pyOpt execution. Note that pyOpt controls the execution, and the
individual optimizers control the iteration."""
self.pyOpt_solution = None
opt_prob = Optimization(self.title, self.objfunc, var_set={}, obj_set={}, con_set={})
# Add all parameters
self.param_type = {}
for name, param in self.get_parameters().iteritems():
# We need to identify Enums, Lists, Dicts
metadata = param.get_metadata()[0][1]
values = param.evaluate()
# Assuming uniform enumerated, discrete, or continuous for now.
val = values[0]
choices = []
if "values" in metadata and isinstance(metadata["values"], (list, tuple, array, set)):
vartype = "d"
choices = metadata["values"]
elif isinstance(val, bool):
vartype = "d"
choices = [True, False]
elif isinstance(val, (int, int32, int64)):
vartype = "i"
elif isinstance(val, (float, float32, float64)):
vartype = "c"
else:
msg = "Only continuous, discrete, or enumerated variables" " are supported. %s is %s." % (
name,
type(val),
)
self.raise_exception(msg, ValueError)
self.param_type[name] = vartype
names = param.names
lower_bounds = param.get_low()
upper_bounds = param.get_high()
for i in range(param.size):
opt_prob.addVar(
names[i], vartype, lower=lower_bounds[i], upper=upper_bounds[i], value=values[i], choices=choices
)
# Add all objectives
for name in self.get_objectives():
opt_prob.addObj(name)
# Add all equality constraints
for name in self.get_eq_constraints():
opt_prob.addCon(name, type="e")
# Add all inequality constraints
for name in self.get_ineq_constraints():
opt_prob.addCon(name, type="i")
# Instantiate the requested optimizer
optimizer = self.optimizer
try:
exec ("from pyOpt import %s" % optimizer)
except ImportError:
msg = "Optimizer %s is not available in this installation." % optimizer
self.raise_exception(msg, ImportError)
optname = vars()[optimizer]
opt = optname()
# Set optimization options
for option, value in self.options.iteritems():
opt.setOption(option, value)
# Execute the optimization problem
if self.pyopt_diff:
# Use pyOpt's internal finite difference
opt(opt_prob, sens_type="FD")
else:
# Use OpenMDAO's differentiator for the gradient
opt(opt_prob, sens_type=self.gradfunc)
# Print results
if self.print_results:
print opt_prob.solution(0)
# Pull optimal parameters back into framework and re-run, so that
# framework is left in the right final state
dvals = []
for i in range(0, len(opt_prob.solution(0)._variables)):
dvals.append(opt_prob.solution(0)._variables[i].value)
# Integer parameters come back as floats, so we need to round them
# and turn them into python integers before setting.
if "i" in self.param_type.values():
for j, param in enumerate(self.get_parameters().keys()):
if self.param_type[param] == "i":
dvals[j] = int(round(dvals[j]))
self.set_parameters(dvals)
self.run_iteration()
self.record_case()
# Save the most recent solution.
self.pyOpt_solution = opt_prob.solution(0)
def main():
###########################################
# Define some values
###########################################
n_blades = 2
n_elements = 10
radius = unit_conversion.in2m(9.6) / 2
root_cutout = 0.1 * radius
dy = float(radius - root_cutout) / n_elements
dr = float(1) / n_elements
y = root_cutout + dy * np.arange(1, n_elements + 1)
r = y / radius
pitch = 0.0
airfoils = (('SDA1075_494p', 0.0, 1.0), )
allowable_Re = [
1000000., 500000., 250000., 100000., 90000., 80000., 70000., 60000.,
50000., 40000., 30000., 20000., 10000.
]
vehicle_weight = 12.455
max_chord = 0.3
max_chord_tip = 5.
alt = 0
tip_loss = True
mach_corr = False
# Forward flight parameters
v_inf = 4. # m/s
alpha0 = 0.0454 # Starting guess for trimmed alpha in radians
n_azi_elements = 5
# Mission times
time_in_hover = 300. # Time in seconds
time_in_ff = 500.
mission_time = [time_in_hover, time_in_ff]
Cl_tables = {}
Cd_tables = {}
Clmax = {}
# Get lookup tables
if any(airfoil[0] != 'simple' for airfoil in airfoils):
for airfoil in airfoils:
Cl_table, Cd_table, Clmax = aero_coeffs.create_Cl_Cd_table(
airfoil[0])
Cl_tables[airfoil[0]] = Cl_table
Cd_tables[airfoil[0]] = Cd_table
Clmax[airfoil[0]] = Clmax
# Create list of Cl functions. One for each Reynolds number. Cl_tables (and Cd_tables) will be empty for the
# 'simple' case, therefore this will be skipped for the simple case. For the full table lookup case this will be
# skipped because allowable_Re will be empty.
Cl_funs = {}
Cd_funs = {}
lift_curve_info_dict = {}
if Cl_tables and allowable_Re:
Cl_funs = dict(
zip(allowable_Re, [
aero_coeffs.get_Cl_fun(Re, Cl_tables[airfoils[0][0]],
Clmax[airfoils[0][0]][Re])
for Re in allowable_Re
]))
Cd_funs = dict(
zip(allowable_Re, [
aero_coeffs.get_Cd_fun(Re, Cd_tables[airfoils[0][0]])
for Re in allowable_Re
]))
lift_curve_info_dict = aero_coeffs.create_liftCurveInfoDict(
allowable_Re, Cl_tables[airfoils[0][0]])
###########################################
# Set design variable bounds
###########################################
# Hover opt 500 gen, 1000 pop, 12.455 N weight, 9.6 in prop
chord = np.array([
0.11923604, 0.2168746, 0.31540216, 0.39822882, 0.42919, 0.35039799,
0.3457828, 0.28567224, 0.23418368, 0.13502483
])
twist = np.array([
0.45316866, 0.38457724, 0.38225075, 0.34671967, 0.33151445, 0.28719111,
0.25679667, 0.25099005, 0.19400679, 0.10926302
])
omega = 3811.03596674 * 2 * np.pi / 60
original = (omega, chord, twist)
dtwist = np.array(
[twist[i + 1] - twist[i] for i in xrange(len(twist) - 1)])
dchord = np.array(
[chord[i + 1] - chord[i] for i in xrange(len(chord) - 1)])
twist0 = twist[0]
chord0 = chord[0]
omega_start = omega
dtwist_start = dtwist
dchord_start = dchord
twist0_start = twist0
chord0_start = chord0
omega_lower = 2000 * 2 * np.pi / 60
omega_upper = 8000.0 * 2 * np.pi / 60
twist0_lower = 0. * 2 * np.pi / 360
twist0_upper = 60. * 2 * np.pi / 360
chord0_upper = 0.1198
chord0_lower = 0.05
dtwist_lower = -10.0 * 2 * np.pi / 360
dtwist_upper = 10.0 * 2 * np.pi / 360
dchord_lower = -0.1
dchord_upper = 0.1
opt_prob = Optimization('Mission Simulator', objfun)
opt_prob.addVar('omega_h',
'c',
value=omega_start,
lower=omega_lower,
upper=omega_upper)
opt_prob.addVar('twist0',
'c',
value=twist0_start,
lower=twist0_lower,
upper=twist0_upper)
opt_prob.addVar('chord0',
'c',
value=chord0_start,
lower=chord0_lower,
upper=chord0_upper)
opt_prob.addVarGroup('dtwist',
n_elements - 1,
'c',
value=dtwist_start,
lower=dtwist_lower,
upper=dtwist_upper)
opt_prob.addVarGroup('dchord',
n_elements - 1,
'c',
value=dchord_start,
lower=dchord_lower,
upper=dchord_upper)
opt_prob.addObj('f')
opt_prob.addCon('thrust', 'i')
opt_prob.addCon('c_tip', 'i')
opt_prob.addConGroup('c_lower', n_elements, 'i')
opt_prob.addConGroup('c_upper', n_elements, 'i')
print opt_prob
slsqp = SLSQP()
slsqp.setOption('IPRINT', 1)
slsqp.setOption('MAXIT', 1000)
slsqp.setOption('ACC', 1e-8)
fstr, xstr, inform = slsqp(opt_prob,
sens_type='FD',
n_blades=n_blades,
radius=radius,
dy=dy,
dr=dr,
y=y,
r=r,
pitch=pitch,
airfoils=airfoils,
vehicle_weight=vehicle_weight,
max_chord=max_chord,
tip_loss=tip_loss,
mach_corr=mach_corr,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
Cl_tables=Cl_tables,
Cd_tables=Cd_tables,
allowable_Re=allowable_Re,
alt=alt,
v_inf=v_inf,
alpha0=alpha0,
mission_time=mission_time,
n_azi_elements=n_azi_elements,
lift_curve_info_dict=lift_curve_info_dict,
max_chord_tip=max_chord_tip)
print opt_prob.solution(0)
# pop_size = 300
# max_gen = 500
# opt_method = 'nograd'
# nsga2 = NSGA2()
# nsga2.setOption('PrintOut', 2)
# nsga2.setOption('PopSize', pop_size)
# nsga2.setOption('maxGen', max_gen)
# nsga2.setOption('pCross_real', 0.85)
# nsga2.setOption('xinit', 1)
# fstr, xstr, inform = nsga2(opt_prob, n_blades=n_blades, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch,
# airfoils=airfoils, vehicle_weight=vehicle_weight, max_chord=max_chord, tip_loss=tip_loss,
# mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables,
# Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method, alt=alt,
# v_inf=v_inf, alpha0=alpha0, mission_time=mission_time, n_azi_elements=n_azi_elements,
# pop_size=pop_size, max_gen=max_gen, lift_curve_info_dict=lift_curve_info_dict,
# max_chord_tip=max_chord_tip)
# print opt_prob.solution(0)
# opt_method = 'nograd'
# xstart_alpso = np.concatenate((np.array([omega_start, twist0_start, chord0_start]), dtwist_start, dchord_start))
# alpso = ALPSO()
# alpso.setOption('xinit', 0)
# alpso.setOption('SwarmSize', 200)
# alpso.setOption('maxOuterIter', 100)
# alpso.setOption('stopCriteria', 0)
# fstr, xstr, inform = alpso(opt_prob, xstart=xstart_alpso, n_blades=n_blades, n_elements=n_elements,
# root_cutout=root_cutout, radius=radius, dy=dy, dr=dr, y=y, r=r, pitch=pitch,
# airfoils=airfoils, thrust=thrust, max_chord=max_chord, tip_loss=tip_loss,
# mach_corr=mach_corr, Cl_funs=Cl_funs, Cd_funs=Cd_funs, Cl_tables=Cl_tables,
# Cd_tables=Cd_tables, allowable_Re=allowable_Re, opt_method=opt_method)
# print opt_prob.solution(0)
def get_performance(o, c, t):
chord_meters = c * radius
prop = propeller.Propeller(t,
chord_meters,
radius,
n_blades,
r,
y,
dr,
dy,
airfoils=airfoils,
Cl_tables=Cl_tables,
Cd_tables=Cd_tables)
quad = quadrotor.Quadrotor(prop, vehicle_weight)
ff_kwargs = {
'propeller': prop,
'pitch': pitch,
'n_azi_elements': n_azi_elements,
'allowable_Re': allowable_Re,
'Cl_funs': Cl_funs,
'Cd_funs': Cd_funs,
'tip_loss': tip_loss,
'mach_corr': mach_corr,
'alt': alt,
'lift_curve_info_dict': lift_curve_info_dict
}
trim0 = np.array([alpha0, o])
alpha_trim, omega_trim, converged = trim.trim(quad, v_inf, trim0,
ff_kwargs)
T_ff, H_ff, P_ff = bemt.bemt_forward_flight(
quad,
pitch,
omega_trim,
alpha_trim,
v_inf,
n_azi_elements,
alt=alt,
tip_loss=tip_loss,
mach_corr=mach_corr,
allowable_Re=allowable_Re,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
lift_curve_info_dict=lift_curve_info_dict)
dT_h, P_h = bemt.bemt_axial(prop,
pitch,
o,
allowable_Re=allowable_Re,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
tip_loss=tip_loss,
mach_corr=mach_corr,
alt=alt)
return sum(dT_h), P_h, T_ff, P_ff, alpha_trim, omega_trim
omega = xstr[0]
twist0 = xstr[1]
chord0 = xstr[2]
dtwist = xstr[3:3 + len(r) - 1]
dchord = xstr[3 + len(r) - 1:]
twist = calc_twist_dist(twist0, dtwist)
chord = calc_chord_dist(chord0, dchord)
print "chord = " + repr(chord)
print "twist = " + repr(twist)
# twist_base = calc_twist_dist(twist0_base, dtwist_base)
# chord_base = calc_chord_dist(chord0_base, dchord_base)
perf_opt = get_performance(omega, chord, twist)
perf_orig = get_performance(original[0], original[1], original[2])
print "omega_orig = " + str(original[0])
print "Hover Thrust of original = " + str(perf_orig[0])
print "Hover Power of original = " + str(perf_orig[1])
print "FF Thrust of original = " + str(perf_orig[2])
print "FF Power of original = " + str(perf_orig[3])
print "Trim original (alpha, omega) = (%f, %f)" % (perf_orig[4],
perf_orig[5])
print "omega = " + str(omega * 60 / 2 / np.pi)
print "Hover Thrust of optimized = " + str(perf_opt[0])
print "Hover Power of optimized = " + str(perf_opt[1])
print "FF Thrust of optimized = " + str(perf_opt[2])
print "FF Power of optimized = " + str(perf_opt[3])
print "Trim optimized (alpha, omega) = (%f, %f)" % (perf_opt[4],
perf_opt[5])
# print "Omega base = " + str(omega_start*60/2/np.pi)
# print "Thrust of base = " + str(sum(perf_base[0]))
# print "Power of base = " + str(sum(perf_base[1]))
#
plt.figure(1)
plt.plot(r, original[1], '-b')
plt.plot(r, chord, '-r')
plt.xlabel('radial location')
plt.ylabel('c/R')
plt.legend(['start', 'opt'])
plt.figure(2)
plt.plot(r, original[2] * 180 / np.pi, '-b')
plt.plot(r, twist * 180 / np.pi, '-r')
plt.xlabel('radial location')
plt.ylabel('twist')
plt.legend(['start', 'opt'])
plt.show()
def optimize_twist(**k):
omega = k['omega']
omega_lower = k['omega_lower']
omega_upper = k['omega_upper']
twist0 = k['twist0']
twist0_lower = k['twist0_lower']
twist0_upper = k['twist0_upper']
n_elements = k['n_elements']
dtwist = k['dtwist']
dtwist_lower = k['dtwist_lower']
dtwist_upper = k['dtwist_upper']
opt_prob_fc = Optimization('Rotor in Hover w/ Fixed Chord',
objfun_optimize_twist)
opt_prob_fc.addVar('omega',
'c',
value=omega,
lower=omega_lower,
upper=omega_upper)
opt_prob_fc.addVar('twist0',
'c',
value=twist0,
lower=twist0_lower,
upper=twist0_upper)
opt_prob_fc.addVarGroup('dtwist',
n_elements - 1,
'c',
value=dtwist,
lower=dtwist_lower,
upper=dtwist_upper)
opt_prob_fc.addObj('f')
opt_prob_fc.addCon('thrust', 'i')
n_blades = k['n_blades']
root_cutout = k['root_cutout']
radius = k['radius']
dy = k['dy']
dr = k['dr']
y = k['y']
r = k['r']
pitch = k['pitch']
airfoils = k['airfoils']
thrust = k['thrust']
chord = k['chord']
allowable_Re = k['allowable_Re']
Cl_tables = k['Cl_tables']
Cd_tables = k['Cd_tables']
Cl_funs = k['Cl_funs']
Cd_funs = k['Cd_funs']
tip_loss = k['tip_loss']
mach_corr = k['mach_corr']
alt = k['alt']
# Routine for optimizing twist with a constant chord
slsqp2 = SLSQP()
slsqp2.setOption('IPRINT', 1)
slsqp2.setOption('MAXIT', 200)
slsqp2.setOption('ACC', 1e-7)
fstr, xstr, inform = slsqp2(opt_prob_fc,
sens_type='FD',
n_blades=n_blades,
n_elements=n_elements,
root_cutout=root_cutout,
radius=radius,
dy=dy,
dr=dr,
y=y,
r=r,
pitch=pitch,
airfoils=airfoils,
thrust=thrust,
tip_loss=tip_loss,
mach_corr=mach_corr,
omega=omega,
chord=chord,
allowable_Re=allowable_Re,
Cl_tables=Cl_tables,
Cd_tables=Cd_tables,
Cl_funs=Cl_funs,
Cd_funs=Cd_funs,
alt=alt)
return fstr, xstr
return g_obj, g_con, fail
# =============================================================================
#
# =============================================================================
# Instantiate Optimization Problem
opt_prob = Optimization('HS 071', objfunc)
opt_prob.addVar('x1', 'c', value=1., lower=1., upper=5.)
opt_prob.addVar('x2', 'c', value=5., lower=1., upper=5.)
opt_prob.addVar('x3', 'c', value=5., lower=1., upper=5.)
opt_prob.addVar('x4', 'c', value=1., lower=1., upper=5.)
opt_prob.addObj('f')
opt_prob.addCon('g1', 'e', equal=40.)
opt_prob.addCon('g2', 'i', lower=25., upper=numpy.inf)
print opt_prob
# Instantiate Optimizer (IPOPT)
ipopt = IPOPT()
# Solve Problem with Optimizer Using Finite Differences
ipopt.setOption('output_file', 'ipopt.out')
ipopt.setOption('max_iter', 2000)
ipopt.setOption('linear_system_scaling', 'none')
ipopt.setOption('tol', 1e-2)
ipopt.setOption("max_cpu_time", 20.)
ipopt(opt_prob, sens_type='FD', store_hst=True)
def execute(self):
"""pyOpt execution. Note that pyOpt controls the execution, and the
individual optimizers control the iteration."""
self.pyOpt_solution = None
opt_prob = Optimization(self.title, self.objfunc, var_set={},
obj_set={}, con_set={})
# Add all parameters
for name, param in self.get_parameters().iteritems():
val = param.evaluate()
# We need to identify Enums, Lists, Dicts
metadata = param.get_metadata()[0][1]
# enumerated, discrete or continuous
choices = []
if ('values' in metadata and \
isinstance(metadata['values'],(list, tuple, array, set))):
vartype = 'd'
choices = metadata['values']
elif isinstance(val, bool):
vartype = 'd'
choices = [True, False]
elif isinstance(val, (int, int32, int64)):
vartype = 'i'
elif isinstance(val, (float, float32, float64)):
vartype = 'c'
else:
msg = 'Only continuous, descrete, or enumerated variables ' + \
'are supported. %s is %s.' % (name, type(val))
self.raise_exception(msg, ValueError)
opt_prob.addVar(name, vartype, lower=param.low, upper=param.high,
value=val, choices=choices)
# Add all objectives
for name in self.get_objectives().keys():
opt_prob.addObj(name)
# Add all equality constraints
for name in self.get_eq_constraints().keys():
opt_prob.addCon(name, type='e')
# Add all inequality constraints
for name in self.get_ineq_constraints().keys():
opt_prob.addCon(name, type='i')
# Instantiate the requested optimizer
optimizer = self.optimizer
try:
exec('from pyOpt import %s' % optimizer)
except ImportError:
msg = "Optimizer %s is not avialable in this installation." % \
optimizer
self.raise_exception(msg, ImportError)
optname = vars()[optimizer]
opt = optname()
# Set optimization options
for option, value in self.options.iteritems():
opt.setOption(option, value)
# Execute the optimization problem
if self.differentiator:
# Use OpenMDAO's differentiator for the gradient
opt(opt_prob, sens_type=self.gradfunc)
else:
# Use pyOpt's internal finite difference
opt(opt_prob, sens_type='FD')
# Print results
if self.print_results:
print opt_prob.solution(0)
# Pull optimal parameters back into framework and re-run, so that
# framework is left in the right final state
dvals = []
for i in range(0, len(opt_prob.solution(0)._variables)):
dvals.append(opt_prob.solution(0)._variables[i].value)
self.set_parameters(dvals)
self.run_iteration()
# Save the most recent solution.
self.pyOpt_solution = opt_prob.solution(0)
fail = 0
return f,g, fail
# =============================================================================
#
# =============================================================================
# Instantiate Optimization Problem
opt_prob = Optimization('TP37 Constrained Problem',objfunc)
opt_prob.addVar('x1','c',lower=0.0,upper=42.0,value=10.0)
opt_prob.addVar('x2','c',lower=0.0,upper=42.0,value=10.0)
opt_prob.addVar('x3','c',lower=0.0,upper=42.0,value=10.0)
opt_prob.addObj('f')
opt_prob.addCon('g1','i')
opt_prob.addCon('g2','i')
# Solve Problem (No-Parallelization)
nlpqlp_none = NLPQLP()
nlpqlp_none.setOption('IPRINT',0)
nlpqlp_none(opt_prob)
if myrank == 0:
print(opt_prob.solution(0))
#end
# Solve Problem (Parallel Gradient)
nlpqlp_pgc = NLPQLP()
nlpqlp_pgc.setOption('IPRINT',0)
nlpqlp_pgc(opt_prob,sens_mode='pgc')
if myrank == 0:
def unscale(x):
y = x
return y
design_problem = PyOptOptimization(dp.comm, dp.eval_objcon, dp.eval_objcon_grad,
number_of_steps=1,
unscale_design_variables=unscale)
opt_prob = Optimization('Aerothermoelasticity', design_problem.eval_obj_con)
opt_prob.addObj('Average Temperature')
opt_prob.addVar('x1', type='c', value=t0, lower=0.1, upper=1.0)
opt_prob.addVar('x2', type='c', value=t0, lower=0.1, upper=1.0)
opt_prob.addVar('x3', type='c', value=t0, lower=0.1, upper=1.0)
opt_prob.addCon('maximum mass', type='i', lower=-np.inf, upper=np.inf, equal=0.0)
if 'verify' in sys.argv:
x0 = np.array([t], TransferScheme.dtype)
f0, c0, fail = dp.eval_obj(x0)
g, A, fail = dp.eval_obj_grad(x0, f0, c0)
for dh in [1e-6, 5e-7, 1e-7, 5e-8, 1e-8]:
x = x0 + dh
f1, c1, fail = dp.eval_obj(x)
fd = (c1[0] - c0[0])/dh
rel_err = (fd - A[0,0])/fd
print('Finite-difference interval: %25.15e'%(dh))
print('Finite-difference value: %25.15e'%(fd))
print('Gradient value: %25.15e'%(A[0,0]))
print('Relative error: %25.15e'%(rel_err))
# Physical problem
rho = 0.2836 # lb/in^3
L = 5.0 # in
P = 25000.0 # lb
E = 30.0e6 # psi
ys = 36260.0 # psi
fs = 1.5
dtruss = TwoBarTruss(rho, L, P, E, ys, fs)
# Optimization Problem
optproblem = TwoBarTrussOpt(MPI.COMM_WORLD, dtruss)
opt_prob = Optimization(args.logfile, optproblem.evalObjCon)
# Add functions
opt_prob.addObj('weight')
opt_prob.addCon('buckling-bar1', type='i')
opt_prob.addCon('failure-bar1', type='i')
opt_prob.addCon('failure-bar2', type='i')
# Add variables
opt_prob.addVar('area-1', type='c', value=1.0, lower=1.0e-3, upper=2.0)
opt_prob.addVar('area-2', type='c', value=1.0, lower=1.0e-3, upper=2.0)
opt_prob.addVar('height', type='c', value=4.0, lower=4.0, upper=10.0)
# Optimization algorithm
if args.algorithm == 'ALGENCAN':
opt = ALGENCAN()
opt.setOption('iprint', 2)
opt.setOption('epsfeas', 1e-6)
opt.setOption('epsopt', 1e-6)
else:
class GP_SS(Algorithm):
""" Implementation of Building Identification and Control using Gaussian Process
State-Space models. A GP regression model per state is created and then the
constrained optimization problem is solved using PyOpt's SLSQP solver."""
def __init__(self):
"""Initialize the GP_SS algorithm for a specific building.
"""
print("Initializing the GP_SS...")
self.building = Building()
self.X = []
self.Y = []
self.dynModels = []
# Number of Initial Exploration Simulation
self.initExploration = 36
# Number of Samples for witching to Sparse Gaussian Processes
self.num_inducing = 2000
# Safety constraint for exploration
self.explorationConstraint = 0.03
# Needed to determine the best controller out of all iterations
self.costs = []
self.constraints = []
self.policies = []
self.baseline = []
def configure(self, building):
# Get building and optimization setup properties
self.building = deepcopy(building)
self.T, self.states, self.actions, self.disturbances, self.controlLim, self.actionLim, self.comfort, self.occ, self.nvars, self.ncons = self.building.getConfiguration(
)
# Run initial random simulations and contstruct initial dataset
for ii in range(0, self.initExploration):
self.building.rand = 1
xa, cf, cc = self.building.simulate(self.building.policy)
xx = xa[0:-1, ]
yy = xa[1:, self.states]
if (ii == 0):
self.X = xx
self.Y = yy
else:
self.X = np.concatenate((self.X, xx), axis=0)
self.Y = np.concatenate((self.Y, yy), axis=0)
# Last simulation is the baseline controller
self.building.rand = 0
xa, cf, cc = self.building.simulate(self.building.policy)
self.baseline.append(self.building.policy)
self.baseline.append(np.sum(cf))
self.baseline.append(np.sum(cc))
xx = xa[0:-1, ]
yy = xa[1:, self.states]
self.X = np.concatenate((self.X, xx), axis=0)
self.Y = np.concatenate((self.Y, yy), axis=0)
def optimize(self, options):
# Set max number of optimization iterations
maxIter = 1
if (len(options) > 0):
maxIter = options["MAXIT"]
# Log costs and constraints for all internal iterations
self.costs = np.zeros((maxIter + 1, 1))
self.constraints = np.zeros((maxIter + 1, self.ncons))
self.policies = np.zeros((maxIter + 1, self.nvars))
# GP_SS process
initPolicy = self.building.policy.copy()
for ii in range(maxIter):
# Train GP state-space models
kernel = GPy.kern.Matern52(self.X.shape[1], ARD=False)
for jj in range(0, len(self.states)):
if (self.X.shape[0] > self.num_inducing):
print("Using Sparse GP Model...")
dynModel = GPy.models.SparseGPRegression(
self.X,
self.Y[:, jj].reshape(self.Y.shape[0], 1),
kernel,
num_inducing=self.num_inducing)
self.dynModels.append(dynModel.copy())
else:
print("Using Full GP Model...")
dynModel = GPy.models.GPRegression(
self.X, self.Y[:, jj].reshape(self.Y.shape[0], 1),
kernel)
dynModel.optimize_restarts(num_restarts=2)
dynModel.optimize('bfgs', messages=True, max_iters=5000)
self.dynModels.append(dynModel.copy())
print(self.dynModels[jj])
self.checkModelAccuracy(dynModel, self.X, self.Y[:, jj])
# Define Box Constraints (min/max values) for the control parameters
boxConstraints = []
for jj in range(self.nvars):
boxConstraints.append(self.controlLim)
# Link to the python function calculating the cost and the constraints. Note that
# this is not the actual simulation, but the propagate function
self.opt_prob = Optimization('GPSS_SLSQP Constrained Problem',
self.propagate)
# Setupt Box Constrains in pyOpt
for jj in range(self.nvars):
self.opt_prob.addVar('x' + str(jj + 1),
'c',
lower=boxConstraints[jj][0],
upper=boxConstraints[jj][1],
value=self.building.policy[0, jj])
# Setupt Cost Function in pyOpt
self.opt_prob.addObj('f')
# Setupt Inequality Constraints in pyOpt
for jj in range(self.ncons + 1):
self.opt_prob.addCon('g' + str(jj + 1), 'i')
# Print the Optimization setup
print("----------------------------------------")
print("----------------------------------------")
print("GPSS_SLSQP Optimization setup:")
print(self.opt_prob)
optionsSLSQP = {'ACC': 1.0e-20, 'MAXIT': 10000, 'IPRINT': 1}
# Set SLSQP as the optimizer
self.opt = SLSQP()
# Set optimization options
for jj in range(len(optionsSLSQP)):
self.opt.setOption(optionsSLSQP.keys()[jj],
optionsSLSQP.values()[jj])
# Print the Optimizer Options
print("----------------------------------------")
print("----------------------------------------")
print("SLSQP Optimizer options:")
print(self.opt.options)
# Get optimized controller
self.opt(self.opt_prob, sens_step=1e-6)
print(self.opt_prob.solution(0))
a = self.opt_prob.solution(0)
for jj in range(self.building.policy.shape[1]):
self.building.policy[0, jj] = a.getVar(jj).value
# Evaluate the optimized controller in the simulation model
xa, cf, cc = self.building.simulate(self.building.policy)
print("COST: = =========== " + str(np.sum(cf)))
print("CONSTRAINT: = =========== " + str(np.sum(cc)))
xx = xa[0:-1, ]
yy = xa[1:, self.states]
if (ii == 0):
self.X = xx
self.Y = yy
else:
self.X = np.concatenate((self.X, xx), axis=0)
self.Y = np.concatenate((self.Y, yy), axis=0)
self.costs[ii, 0] = np.sum(cf)
for jj in range(self.ncons):
self.constraints[ii, jj] = np.sum(cc[:, jj])
self.policies[ii, :] = self.building.policy.copy()
self.building.policy = initPolicy.copy()
self.policies[ii + 1, :] = self.baseline[0].copy()
self.costs[ii + 1, 0] = self.baseline[1]
self.constraints[ii + 1, 0] = self.baseline[2]
policyIndex = self.selectBestController(self.costs, self.constraints)
self.building.policy = self.policies[policyIndex, :].copy()
return self.building.policy
def selectBestController(self, costs, constraints):
"""A function that selects the best controller out of a set of controllers,
based on their performance on the cost function and the constraints.
Args:
costs (numpy array): The resulting cost of each controller, as evaluated
on the simulation model
constraints (numpy array): The resulting constraints of each controller, as evaluated
on the simulation model
Returns:
policyIndex (float): the index of the best controller
"""
wCost = 1
wConstraints = 10000000
p = np.zeros((costs.shape[0], 1))
for ii in range(costs.shape[0]):
p[ii, 0] = p[ii, 0] + wCost * costs[ii, 0]
for jj in range(constraints.shape[1]):
p[ii, 0] = p[ii, 0] + wConstraints * constraints[ii, jj]
policyIndex = np.argmin(p)
return policyIndex
def propagate(self, policy):
"""A function that uses the GP state-space models identified from the data
to perform rollouts based on a given controller.
Args:
policy (numpy array): the controller to be used for the rollout
Returns:
f (float): the cost function value
g (list): the vales of all constraints
fail (0/1): indicates if the function finished successfully
"""
# Initial state
xx = np.zeros((self.building.T + 1,
len(self.building.states) + self.building.w.shape[1]))
uu = np.zeros((self.building.T + 1, len(self.building.actions)))
cc = np.zeros((self.building.T + 1, 1))
cf = np.zeros((self.building.T + 1, 1))
var = np.zeros((self.building.T, len(self.building.states)))
xx[0, ] = self.X[0, 0:2] # [17, w[0,]]
uu[0, ] = self.building.controller(policy, xx[0, ], 0)
cc[0, ] = self.building.comfortConstraints(xx[0, self.building.states],
0)
cf[0, ] = self.building.costFunction(uu[0, ], 0)
# state propagation using the provided controller
for ii in range(1, self.building.T + 1):
newX = np.hstack([xx[ii - 1, ],
uu[ii - 1]]).reshape(1,
xx.shape[1] + uu.shape[1])
for jj in range(0, len(self.building.states)):
results = self.dynModels[jj].predict(newX)
xx[ii, jj] = results[0]
var[ii - 1, jj] = results[1]
xx[ii, 1] = self.building.w[ii, ]
uu[ii, ] = self.building.controller(policy, xx[ii, ], ii)
cc[ii, ] = self.building.comfortConstraints(
xx[ii, self.building.states], ii)
cf[ii, ] = self.building.costFunction(uu[ii, ], ii)
f = np.sum(cf)
g = []
g.append(np.mean(var) -
self.explorationConstraint) # Exploration constraint
g.append(np.sum(cc))
fail = 0
return f, g, fail
def checkModelAccuracy(self, dynModel, xtest, ytest):
"""A function that evaluates the accuracy of the GP state-space model.
Args:
dynModel (GPy object): The GP model
xtest (numpy array): The features of the regression
ytest (numpy array): The targets of the regression
"""
results = dynModel.predict(xtest)
ypred = results[0]
# sGP = results[1]
rsqTrain, maeTrain, rsqAdjTrain = self.evaluateGoodnessOfFit(
xtest, ytest, ypred)
print("Rsq train Gaussian Processes Regression = " + str(rsqTrain))
print("Rsq Adjusted train Gaussian Processes Regression = " +
str(rsqAdjTrain))
print("MAE train Gaussian Processes Regression = " + str(maeTrain))
def evaluateGoodnessOfFit(self, x, y, ypred):
"""A function that evaluates the goodness of fit, under different measures.
Args:
x (numpy array): The features of the regression
y (numpy array): The targets of the regression
ypred (numpy array): The predictions of the regression model
Returns:
Rsquared (float): R-squared
mae (float): Mean Absolute Error
rsqAdj (float): The Adjusted R-square
"""
print(y.shape[0])
print(x.shape[1])
y_hat = np.mean(y)
SStot = np.sum(np.power(y - y_hat, 2))
SSres = np.sum(np.power(y - ypred.flatten(), 2))
if (SStot == 0):
rsq = 1
else:
rsq = 1 - SSres / SStot
mae = np.sum(np.abs(y - ypred.flatten())) / ypred.shape[0]
rsqAdj = 1 - (1 - rsq) * (y.shape[0] - 1) / (y.shape[0] - x.shape[1] -
1)
return rsq, mae, rsqAdj
def wrapSimulation(self, policy):
"""A function that runs a building simulation and wraps the results in the
format required by PyOpt library.
Args:
policy (numpy array): the controller to be used for the simulation
Returns:
f (float): the cost function value
g (list): the vales of all constraints
fail (0/1): indicates if the function finished successfully
"""
# Cost and Constraints
f = 0
g = []
fail = 0
# Run building simulation
x, cost, constraints = self.building.simulate(policy)
f = np.sum(cost)
g.append(np.sum(constraints))
# print(f)
# print(g[0])
return f, g, fail
