def __init__(self):
domain = build_beam_domain()
funs = [
beam_area,
beam_bending,
beam_tip_deflect,
beam_bending_stress,
beam_shear_stress,
beam_area_ratio,
beam_twist_buckling,
]
grads = [
beam_area_grad,
beam_bending_grad,
beam_tip_deflect_grad,
beam_bending_stress_grad,
beam_shear_stress_grad,
beam_area_ratio_grad,
beam_twist_buckling_grad,
]
Function.__init__(self,
funs,
domain,
grads=grads,
vectorized=True,
kwargs=BEAM)
def __init__(self):
domain = build_golinski_design_domain()
funs = [
golinski_volume,
golinski_constraint1,
golinski_constraint2,
golinski_constraint3,
golinski_constraint4,
golinski_constraint5,
golinski_constraint6,
golinski_constraint7,
golinski_constraint8,
golinski_constraint9,
golinski_constraint24,
golinski_constraint25,
]
grads = [
golinski_volume_grad,
golinski_constraint1_grad,
golinski_constraint2_grad,
golinski_constraint3_grad,
golinski_constraint4_grad,
golinski_constraint5_grad,
golinski_constraint6_grad,
golinski_constraint7_grad,
golinski_constraint8_grad,
golinski_constraint9_grad,
golinski_constraint24_grad,
golinski_constraint25_grad,
]
Function.__init__(self, funs, domain, grads=grads, vectorized=True)
def __init__(self, dask_client=None):
domain = build_robot_arm_domain()
funs = [robot_arm]
grads = [robot_arm_grad]
Function.__init__(self,
funs,
domain,
grads=grads,
vectorized=True,
dask_client=dask_client)
def __init__(self,
n_lower=10,
n_upper=10,
fraction=0.01,
dask_client=None,
**kwargs):
domain = build_hicks_henne_domain(n_lower, n_upper, fraction=fraction)
kwargs.update({'n_lower': n_lower, 'n_upper': n_upper})
Function.__init__(self,
naca0012_func,
domain,
vectorized=False,
kwargs=kwargs,
dask_client=dask_client,
return_grad=True)
def __init__(self, domain='deterministic', dask_client=None):
assert domain in ['deterministic', 'uncertain']
if domain == 'deterministic':
domain = build_borehole_domain()
else:
domain = build_borehole_uncertain_domain()
funs = [borehole]
grads = [borehole_grad]
Function.__init__(self,
funs,
domain,
grads=grads,
vectorized=True,
dask_client=dask_client)
def __init__(self, linear=None, constant=None, domain=None):
if linear is None:
if domain is not None:
self.linear = np.random.randn(len(domain))
else:
self.linear = np.random.randn(5)
else:
self.linear = np.array(linear).flatten()
if constant is None:
self.constant = 0
else:
self.constant = float(constant)
if domain is None:
domain = BoxDomain(-np.ones(len(self.linear)),
np.ones(len(self.linear)))
Function.__init__(self,
self._func,
domain,
grads=self._func_grad,
vectorized=True)
def __init__(self,
truncate=1e-7,
level=0,
su2_maxiter=5000,
workdir=None,
dask_client=None,
**kwargs):
self.design_domain_app = buildDesignDomain(output='none',
solver='CVXOPT')
self.design_domain_norm = self.design_domain_app.normalized_domain()
self.design_domain = self.design_domain_norm
self.random_domain_app = buildRandomDomain(truncate=truncate)
self.random_domain_norm = self.random_domain_app.normalized_domain()
self.random_domain = self.random_domain_norm
domain = self.design_domain_app * self.random_domain_app
Function.__init__(self,
multif,
domain,
vectorized=False,
dask_client=dask_client,
kwargs=kwargs)
def __init__(self, quad=None, linear=None, constant=None, domain=None):
# Determine dimension of space
if quad is not None:
m = len(quad)
elif linear is not None:
m = len(linear)
elif domain is not None:
m = len(domain)
else:
m = 5
if quad is not None:
self.quad = np.array(quad).reshape(m, m)
else:
self.quad = np.eye(m)
if linear is not None:
self.linear = np.array(linear).reshape(m)
else:
self.linear = np.zeros(m)
if constant is not None:
self.constant = float(constant)
else:
self.constant = 0.
if domain is None:
domain = BoxDomain(-np.ones(len(self.linear)),
np.ones(len(self.linear)))
Function.__init__(self,
self._func,
domain,
grads=self._func_grad,
vectorized=True)
def __init__(self, n_lower=10, n_upper=10):
domain = build_hicks_henne_domain(n_lower, n_upper)
# build_oas_design_domain() * build_oas_robust_domain() * build_oas_random_domain()
Function.__init__(self, oas_func, domain, vectorized=True)
def __init__(self, dask_client = None): domain = build_piston_domain() funs = [piston] grads = [piston_grad] Function.__init__(self, funs, domain, grads = grads, vectorized = True, dask_client = dask_client)
def __init__(self):
domain = build_hartmann_domain()
funs = [u_ave, Bind]
grads = [u_ave_grad, Bind_grad]
Function.__init__(self, funs, domain, grads=grads, vectorized=True)
def __init__(self):
domain = build_oas_design_domain() * build_oas_robust_domain(
) * build_oas_random_domain()
Function.__init__(self, oas_func, domain, vectorized=True)