def test_optimise_constrained_poly2(self):
n = 2
N = 20
bounds = [0.0, np.inf]
X = np.random.uniform(-1.0, 1.0, (N, n))
# Function values for f and Poly object
f = self.ObjFun1(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('total-order')
fpoly = eq.Poly(fParameters,
myBasis,
method='least-squares',
sampling_args={
'mesh': 'user-defined',
'sample-points': X,
'sample-outputs': f
})
fpoly.set_model()
# Active subspace and values for g1
g1 = self.ConFun1(X)
g1param = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degg1)
g1Parameters = [g1param for i in range(n)]
myBasis = eq.Basis('total-order')
g1poly = eq.Poly(g1Parameters,
myBasis,
method='least-squares',
sampling_args={
'mesh': 'user-defined',
'sample-points': X,
'sample-outputs': g1
})
g1poly.set_model()
for method in ['trust-constr', 'SLSQP', 'COBYLA']:
Opt = eq.Optimisation(method=method)
Opt.add_objective(poly=fpoly)
Opt.add_bounds(-np.ones(n), np.ones(n))
Opt.add_nonlinear_ineq_con({'poly': g1poly, 'bounds': bounds})
x0 = np.zeros(n)
sol = Opt.optimise(x0)
if sol['status'] == 0:
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=2)
def test_optimise_unconstrained_poly(self):
n = 2
N = 20
X = np.random.uniform(-1.0, 1.0, (N, n))
f = self.ObjFun1(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('total-order')
fpoly = eq.Poly(fParameters,
myBasis,
method='least-squares',
sampling_args={
'mesh': 'user-defined',
'sample-points': X,
'sample-outputs': f
})
fpoly.set_model()
for method in [
'BFGS', 'CG', 'Newton-CG', 'L-BFGS-B', 'Powell', 'Nelder-Mead',
'trust-ncg'
]:
Opt = eq.Optimisation(method=method)
Opt.add_objective(fpoly)
x0 = np.random.uniform(-1.0, 1.0, n)
sol = Opt.optimise(x0)
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=3)
def test_optimise_eq_constrained_function2(self):
n = 2
N = 20
value = 2.0
X = np.random.uniform(-1.0, 1.0, (N, n))
f = self.ObjFun1(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('total-order')
fpoly = eq.Poly(fParameters,
myBasis,
method='least-squares',
sampling_args={
'mesh': 'user-defined',
'sample-points': X,
'sample-outputs': f
})
fpoly.set_model()
g1Func = lambda x: value - self.ConFun1(x.reshape(1, -1))
for method in ['trust-constr', 'SLSQP']:
Opt = eq.Optimisation(method=method)
Opt.add_objective(poly=fpoly)
Opt.add_nonlinear_eq_con(custom={'function': g1Func})
x0 = np.zeros(n)
sol = Opt.optimise(x0)
if sol['status'] == 0:
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=2)
def test_optimise_custom_function_linear_ineq_con2(self):
n = 2
N = 20
X = np.random.uniform(-1.0, 1.0, (N, n))
f = self.ObjFun1(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('total-order')
fpoly = eq.Poly(fParameters,
myBasis,
method='least-squares',
sampling_args={
'mesh': 'user-defined',
'sample-points': X,
'sample-outputs': f
})
fpoly.set_model()
for method in ['COBYLA', 'SLSQP', 'trust-constr']:
Opt = eq.Optimisation(method=method)
Opt.add_objective(poly=fpoly)
Opt.add_linear_ineq_con(np.eye(n), -np.ones(n),
np.inf * np.ones(n))
x0 = np.random.uniform(-1.0, 1.0, n)
sol = Opt.optimise(x0)
if sol['status'] == 0:
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=3)
def test_optimizePoly_unconstrained_poly(self):
n = 2
N = 20
X = np.random.uniform(-1.0, 1.0, (N, n))
# Function values for f and Poly object
f = self.ObjFun(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('Total order')
fpoly = eq.Polyreg(fParameters,
myBasis,
training_inputs=X,
training_outputs=f)
for method in [
'BFGS', 'CG', 'Newton-CG', 'L-BFGS-B', 'Powell', 'Nelder-Mead',
'trust-ncg'
]:
Opt = eq.Optimization(method=method)
Opt.addObjective(Poly=fpoly)
x0 = np.random.uniform(-1.0, 1.0, n)
sol = Opt.optimizePoly(x0)
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=3)
def test_optimizePoly_constrained_function(self):
n = 2
N = 20
X = np.random.uniform(-1.0, 1.0, (N, n))
# Function values for f and Poly object
f = self.ObjFun(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('Total order')
fpoly = eq.Polyreg(fParameters,
myBasis,
training_inputs=X,
training_outputs=f)
g1Func = lambda x: self.ConFun1(x.reshape(1, -1))
g1Grad = lambda x: self.ConFun1_Deriv(x.flatten())
g1Hess = lambda x, v: self.ConFun1_Hess(x.flatten())
for method in ['trust-constr', 'SLSQP']:
Opt = eq.Optimization(method=method)
Opt.addObjective(Poly=fpoly)
Opt.addNonLinearIneqCon(self.boundsg1,
Function=g1Func,
jacFunction=g1Grad,
hessFunction=g1Hess)
Opt.addLinearEqCon(np.eye(n), np.ones(n))
x0 = np.zeros(n)
sol = Opt.optimizePoly(x0)
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=2)
def test_optimizePoly_unconstrained_poly_subspace(self):
df = 2
n = 50
N = 5000
X = np.random.uniform(-1.0, 1.0, (N, n))
# Active subspace and values for f
U = sp.linalg.orth(np.random.rand(n, df))
u, f = self.ObjFun_Subspace(X, U)
fparam = eq.Parameter(distribution='uniform',
lower=-6.,
upper=6.,
order=self.degf)
fParameters = [fparam for i in range(df)]
myBasis = eq.Basis('Total order')
fpoly = eq.Polyreg(fParameters,
myBasis,
training_inputs=u,
training_outputs=f)
for method in [
'BFGS', 'CG', 'Newton-CG', 'L-BFGS-B', 'Powell', 'Nelder-Mead',
'trust-ncg'
]:
Opt = eq.Optimization(method=method)
Opt.addObjective(Poly=fpoly, subspace=U)
x0 = np.zeros(n)
sol = Opt.optimizePoly(x0)
np.testing.assert_almost_equal(np.dot(sol['x'], U).flatten(),
np.array([1.0, 1.0]),
decimal=3)
def eval_poly(x, lower, upper, coeffs, W):
mybasis = eq.Basis("total-order")
param = eq.Parameter(distribution='uniform',
lower=lower,
upper=upper,
order=2)
newpoly = eq.Poly(param, mybasis, method='least-squares')
newpoly._set_coefficients(user_defined_coefficients=coeffs)
u = x @ W
ypred = newpoly.get_polyfit(u)
return ypred
def test_optimizePoly_constrained_poly(self):
n = 2
N = 20
X = np.random.uniform(-1.0, 1.0, (N, n))
# Function values for f and Poly object
f = self.ObjFun(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('Total order')
fpoly = eq.Polyreg(fParameters,
myBasis,
training_inputs=X,
training_outputs=f)
# Active subspace and values for g1
g1 = self.ConFun1(X)
g1param = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degg1)
g1Parameters = [g1param for i in range(n)]
myBasis = eq.Basis('Total order')
g1poly = eq.Polyreg(g1Parameters,
myBasis,
training_inputs=X,
training_outputs=g1)
for method in ['trust-constr', 'SLSQP']:
Opt = eq.Optimization(method=method)
Opt.addObjective(Poly=fpoly)
Opt.addLinearIneqCon(np.eye(n), -np.ones(n), np.ones(n))
Opt.addNonLinearIneqCon(self.boundsg1, Poly=g1poly)
x0 = np.zeros(n)
sol = Opt.optimizePoly(x0)
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=2)
def test_optimise_ineq_constrained_function1(self):
n = 2
N = 20
bounds = [-np.inf, 2.0]
X = np.random.uniform(-1.0, 1.0, (N, n))
# Function values for f and Poly object
f = self.ObjFun(X)
fparam = eq.Parameter(distribution='uniform',
lower=-1.,
upper=1.,
order=self.degf)
fParameters = [fparam for i in range(n)]
myBasis = eq.Basis('total-order')
fpoly = eq.Poly(fParameters,
myBasis,
method='least-squares',
sampling_args={
'sample-points': X,
'sample-outputs': f
})
fpoly.set_model()
g1Func = lambda x: bounds[1] - self.ConFun1(x.reshape(1, -1))
g1Grad = lambda x: -self.ConFun1_Deriv(x.flatten())
g1Hess = lambda x: -self.ConFun1_Hess(x.flatten())
for method in ['trust-constr', 'SLSQP']:
Opt = eq.Optimisation(method=method)
Opt.add_objective(poly=fpoly)
Opt.add_nonlinear_ineq_con(
custom={
'function': g1Func,
'jac_function': g1Grad,
'hess_function': g1Hess
})
Opt.add_linear_eq_con(np.eye(n), np.ones(n))
x0 = np.zeros(n)
sol = Opt.optimise(x0)
if sol['status'] == 0:
np.testing.assert_almost_equal(sol['x'].flatten(),
np.array([1.0, 1.0]),
decimal=2)
def display_active_plot(clickData,airfoil_data,var):
# Sufficient summary plot
layout1={"xaxis": {"title": r'$\mathbf{W}^T\mathbf{x}$'}, "yaxis": {"title": var_name[var]},'margin':{'t':0,'r':0,'l':0,'b':60},
'paper_bgcolor':'white','plot_bgcolor':'white','autosize':True}
fig1 = go.Figure(layout=layout1)
fig1.update_xaxes(color='black',linecolor='black',showline=True,tickcolor='black',ticks='outside')
fig1.update_yaxes(color='black',linecolor='black',showline=True,tickcolor='black',ticks='outside')
# W projection plot
layout2={'margin':dict(t=0,r=0,l=0,b=0,pad=0),'showlegend':False,"xaxis": {"title": r'$x/C$'}, "yaxis": {"title": r'$y/C$'},
'paper_bgcolor':'white','plot_bgcolor':'white','autosize':True}#,'height':350}
fig2 = go.Figure(layout=layout2)
fig2.update_xaxes(title=r'$x/C$',range=[-0.02,1.02],showgrid=True, zeroline=False, visible=True,gridcolor='rgba(0,0,0,0.2)',showline=True,linecolor='black')
fig2.update_yaxes(scaleanchor = "x", scaleratio = 1, showgrid=False, showticklabels=False, zeroline=False, visible=False)
fig2.add_trace(go.Scatter(x=base_airfoil[:,0],y=base_airfoil[:,1],mode='lines',line_width=4,line_color='black'))
if clickData is not None:
pointdata = clickData['points'][0]
if "pointIndex" in pointdata: #check click event corresponds to the point cloud
# Get point info
n = pointdata['pointIndex']
xn = pointdata['x']
yn = pointdata['y']
w = W[pts][n,var,:,:]
# Summary plot
##############
# Plot training design
Yn = Y[n,:,var]
u = (X @ w).flatten()
fig1.add_trace(go.Scatter(x=u,y=Yn,mode='markers',name='Training designs',
marker=dict(color='LightSkyBlue',size=15,opacity=0.5,line=dict(color='black',width=1))
))
design_vec = airfoil_data['design-vec']
# Set poly
mybasis = eq.Basis("total-order")
param = eq.Parameter(distribution='uniform', lower=lowers[pts][n,var],upper=uppers[pts][n,var],order=2)
newpoly = eq.Poly(param, mybasis, method='least-squares')
newpoly._set_coefficients(user_defined_coefficients=coeffs[pts][n,var,:])
# Plot poly
u_poly = np.linspace(np.min(u)-0.25,np.max(u)+0.25,50)
Y_poly = newpoly.get_polyfit(u_poly.reshape(-1,1))
fig1.add_trace(go.Scatter(x=u_poly,y=Y_poly.squeeze(),mode='lines',name='Ridge approximation',line_width=4,line_color='black' ))
# Plot deformed design
u_design = design_vec @ w
Y_design = newpoly.get_polyfit(u_design)
fig1.add_trace(go.Scatter(x=u_design.squeeze(),y=Y_design.squeeze(),mode='markers',name='Deformed design',
marker=dict(symbol='circle-open',color='firebrick',size=25,line=dict(width=5))
))
# W projection plot
###################
# Split into suction and pressure
scale = 0.2
wp = -w[0::2,0]*scale
ws = w[1::2,0]*scale
x_bumps = np.linspace(0.05,0.9,25)
airfoilp = base_airfoil[:128,:]
airfoils = base_airfoil[128:,:]
yp = np.interp(x_bumps, airfoilp[::-1,0], airfoilp[::-1,1])
ys = np.interp(x_bumps, airfoils[:,0], airfoils[:,1])
# Pressure
fig2.add_trace(go.Scatter(x=x_bumps,y=yp,mode='lines',line_width=1,line_color='black')) # plot hidden line to use with fill=tonexty below
fig2.add_trace(go.Scatter(x=x_bumps,y=yp+wp,mode='lines',line_width=4,line_color='LightSalmon',fill='tonexty',fillcolor='rgba(255,160,122, 0.3)'))
# Suction
fig2.add_trace(go.Scatter(x=x_bumps,y=ys,mode='lines',line_width=1,line_color='black')) # plot hidden line to use with fill=tonexty below
fig2.add_trace(go.Scatter(x=x_bumps,y=ys+ws,mode='lines',line_width=4,line_color='LightSkyBlue',fill='tonexty',fillcolor='rgba(135,206,250, 0.3)'))
# Pressure annotation
fig2.add_annotation(x=x_bumps[-4],y=yp[-4]+wp[-4],text='Pressure surface deformation',xanchor='right',ax=-50,ay=85,font={'size':14,'color':'LightSalmon'},valign='bottom',showarrow=True,arrowhead=3,arrowsize=2,arrowcolor='LightSalmon')
# Suction annotation
fig2.add_annotation(x=x_bumps[3],y=ys[3]+ws[3],text='Suction surface deformation',xanchor='left',ax=50,ay=-90,font={'size':14,'color':'LightSkyBlue'},valign='top',showarrow=True,arrowhead=3,arrowsize=2,arrowcolor='LightSkyBlue')
return fig1, fig2
def test_optimizePoly_constrained_poly_subspace(self):
df = 2
dg1 = 2
dg2 = 2
n = 50
N = 5000
X = np.random.uniform(-1.0, 1.0, (N, n))
# Active subspace and values for f
U = sp.linalg.orth(np.random.rand(n, df))
u, f = self.ObjFun_Subspace(X, U)
fparam = eq.Parameter(distribution='uniform',
lower=-6.,
upper=6.,
order=self.degf)
fParameters = [fparam for i in range(df)]
myBasis = eq.Basis('Total order')
fpoly = eq.Polyreg(fParameters,
myBasis,
training_inputs=u,
training_outputs=f)
# Active subspace and values for g1
W = sp.linalg.orth(np.random.rand(n, dg1))
w, g1 = self.ConFun1_Subspace(X, W)
g1param = eq.Parameter(distribution='uniform',
lower=-6.,
upper=6.,
order=self.degg1)
g1Parameters = [g1param for i in range(dg1)]
myBasis = eq.Basis('Total order')
g1poly = eq.Polyreg(g1Parameters,
myBasis,
training_inputs=w,
training_outputs=g1)
# Active subspace and values for g2
V = sp.linalg.orth(np.random.rand(n, dg2))
v, g2 = self.ConFun2_Subspace(X, V)
g2param = eq.Parameter(distribution='uniform',
lower=-6.,
upper=6.,
order=self.degg2)
g2Parameters = [g2param for i in range(dg2)]
myBasis = eq.Basis('Total order')
g2poly = eq.Polyreg(g2Parameters,
myBasis,
training_inputs=v,
training_outputs=g2)
for method in ['trust-constr', 'SLSQP']:
Opt = eq.Optimization(method=method)
Opt.addObjective(Poly=fpoly, subspace=U)
Opt.addBounds(-np.ones(n), np.ones(n))
Opt.addNonLinearIneqCon(self.boundsg1, Poly=g1poly, subspace=W)
Opt.addNonLinearEqCon(self.valg2, Poly=g2poly, subspace=V)
x0 = np.zeros(n)
sol = Opt.optimizePoly(x0)
np.testing.assert_almost_equal(np.dot(sol['x'], U).flatten(),
np.array([1.0, 1.0]),
decimal=3)
