def test_vectorized(self):
prob = Problem()
prob.model = model = Group()
x = np.zeros((3, 5))
x[0, :] = np.array([3.0, 5.0, 11.0, 13.0, 17.0])
x[1, :] = np.array([13.0, 11.0, 5.0, 17.0, 3.0]) * 2
x[2, :] = np.array([11.0, 3.0, 17.0, 5.0, 13.0]) * 3
model.add_subsystem('px', IndepVarComp(name="x", val=x))
model.add_subsystem('ks', KSComp(width=5, vec_size=3))
model.connect('px.x', 'ks.g')
model.add_design_var('px.x')
model.add_constraint('ks.KS', upper=0.0)
prob.setup(check=False)
prob.run_driver()
assert_rel_error(self, prob['ks.KS'][0], 17.0)
assert_rel_error(self, prob['ks.KS'][1], 34.0)
assert_rel_error(self, prob['ks.KS'][2], 51.0)
partials = prob.check_partials(includes=['ks'], out_stream=None)
for (of, wrt) in partials['ks']:
assert_rel_error(self, partials['ks'][of, wrt]['abs error'][0],
0.0, 1e-6)
def test_partials_no_compute(self):
prob = Problem()
model = prob.model
model.add_subsystem('px', IndepVarComp('x', val=np.array([5.0, 4.0])))
ks_comp = model.add_subsystem('ks', KSComp(width=2))
model.connect('px.x', 'ks.g')
prob.setup(check=False)
prob.run_driver()
# compute partials with the current model inputs
inputs = { 'g': prob['ks.g'] }
partials = {}
ks_comp.compute_partials(inputs, partials)
assert_rel_error(self, partials[('KS', 'g')], np.array([1., 0.]), 1e-6)
# swap inputs and call compute partials again, without calling compute
inputs['g'][0][0] = 4
inputs['g'][0][1] = 5
ks_comp.compute_partials(inputs, partials)
assert_rel_error(self, partials[('KS', 'g')], np.array([0., 1.]), 1e-6)
def test_lower_flag(self):
prob = Problem()
model = prob.model
model.add_subsystem('px', IndepVarComp('x', val=np.array([5.0, 4.0])))
model.add_subsystem('comp', ExecComp('y = 3.0*x', x=np.zeros((2, )), y=np.zeros((2, ))))
model.add_subsystem('ks', KSComp(width=2))
model.connect('px.x', 'comp.x')
model.connect('comp.y', 'ks.g')
model.ks.options['lower_flag'] = True
prob.setup()
prob.run_model()
assert_rel_error(self, prob['ks.KS'][0], -12.0)
def test_basic_ks(self):
prob = Problem()
prob.model = model = Group()
model.add_subsystem('px', IndepVarComp(name="x", val=np.ones((2, ))))
model.add_subsystem('comp', DoubleArrayComp())
model.add_subsystem('ks', KSComp(width=2))
model.connect('px.x', 'comp.x1')
model.connect('comp.y2', 'ks.g')
model.add_design_var('px.x')
model.add_objective('comp.y1')
model.add_constraint('ks.KS', upper=0.0)
prob.setup(check=False)
prob.run_driver()
assert_rel_error(self, max(prob['comp.y2']), prob['ks.KS'][0])
def test_basic(self):
import numpy as np
from openmdao.api import Problem, IndepVarComp, ExecComp
from openmdao.components.ks_comp import KSComp
prob = Problem()
model = prob.model
model.add_subsystem('px', IndepVarComp('x', val=np.array([5.0, 4.0])))
model.add_subsystem('comp', ExecComp('y = 3.0*x', x=np.zeros((2, )), y=np.zeros((2, ))))
model.add_subsystem('ks', KSComp(width=2))
model.connect('px.x', 'comp.x')
model.connect('comp.y', 'ks.g')
prob.setup()
prob.run_model()
assert_rel_error(self, prob['ks.KS'][0], 15.0)
def setup(self):
E = self.options['E']
L = self.options['L']
b = self.options['b']
volume = self.options['volume']
max_bending = self.options['max_bending']
num_elements = self.options['num_elements']
num_nodes = num_elements + 1
num_cp = self.options['num_cp']
num_load_cases = self.options['num_load_cases']
parallel_derivs = self.options['parallel_derivs']
inputs_comp = IndepVarComp()
inputs_comp.add_output('h_cp', shape=num_cp)
self.add_subsystem('inputs_comp', inputs_comp)
comp = BsplinesComp(num_control_points=num_cp,
num_points=num_elements,
in_name='h_cp',
out_name='h')
self.add_subsystem('interp', comp)
I_comp = MomentOfInertiaComp(num_elements=num_elements, b=b)
self.add_subsystem('I_comp', I_comp)
comp = LocalStiffnessMatrixComp(num_elements=num_elements, E=E, L=L)
self.add_subsystem('local_stiffness_matrix_comp', comp)
# Parallel Subsystem for load cases.
par = self.add_subsystem('parallel', ParallelGroup())
# Determine how to split cases up over the available procs.
nprocs = self.comm.size
divide = divide_cases(num_load_cases, nprocs)
for j, this_proc in enumerate(divide):
num_rhs = len(this_proc)
name = 'sub_%d' % j
sub = par.add_subsystem(name, Group())
# Load is a sinusoidal distributed force of varying spatial frequency.
force_vector = np.zeros((2 * num_nodes, num_rhs))
for i, k in enumerate(this_proc):
end = 1.5 * np.pi
if num_load_cases > 1:
end += k * 0.5 * np.pi / (num_load_cases - 1)
x = np.linspace(0, end, num_nodes)
f = -np.sin(x)
force_vector[0:-1:2, i] = f
comp = MultiStatesComp(num_elements=num_elements,
force_vector=force_vector,
num_rhs=num_rhs)
sub.add_subsystem('states_comp', comp)
comp = MultiDisplacementsComp(num_elements=num_elements,
num_rhs=num_rhs)
sub.add_subsystem('displacements_comp', comp)
comp = MultiStressComp(num_elements=num_elements,
E=E,
num_rhs=num_rhs)
sub.add_subsystem('stress_comp', comp)
self.connect('local_stiffness_matrix_comp.K_local',
'parallel.%s.states_comp.K_local' % name)
for k in range(num_rhs):
sub.connect('states_comp.d_%d' % k,
'displacements_comp.d_%d' % k)
sub.connect('displacements_comp.displacements_%d' % k,
'stress_comp.displacements_%d' % k)
comp = KSComp(width=num_elements)
comp.options['upper'] = max_bending
sub.add_subsystem('KS_%d' % k, comp)
sub.connect('stress_comp.stress_%d' % k, 'KS_%d.g' % k)
if parallel_derivs:
color = 'red_%d' % k
else:
color = None
sub.add_constraint('KS_%d.KS' % k,
upper=0.0,
parallel_deriv_color=color)
comp = VolumeComp(num_elements=num_elements, b=b, L=L)
self.add_subsystem('volume_comp', comp)
self.connect('inputs_comp.h_cp', 'interp.h_cp')
self.connect('interp.h', 'I_comp.h')
self.connect('I_comp.I', 'local_stiffness_matrix_comp.I')
self.connect('interp.h', 'volume_comp.h')
self.add_design_var('inputs_comp.h_cp', lower=1e-2, upper=10.)
self.add_objective('volume_comp.volume')
