def run_open_mdao():
if USE_SCALING:
# prepare scaling
global offset_weight
global offset_stress
global scale_weight
global scale_stress
runner = MultiRun(use_calcu=not USE_ABA, use_aba=USE_ABA, non_liner=False, project_name_prefix=PROJECT_NAME_PREFIX,
force_recalc=False)
sur = Surrogate(use_abaqus=USE_ABA, pgf=False, show_plots=False, scale_it=False)
res, surro = sur.auto_run(SAMPLE_HALTON, 16, SURRO_POLYNOM, run_validation=False)
p = runner.new_project_r_t(range_rib[0], range_shell[0])
offset_weight = p.calc_wight()
p = runner.new_project_r_t(range_rib[1], range_shell[1])
max_weight = p.calc_wight()
offset_stress = surro.predict([range_rib[1], range_shell[1]])
max_stress = surro.predict([range_rib[0], range_shell[0]])
scale_weight = (max_weight - offset_weight)
scale_stress = (max_stress - offset_stress)
write_mdao_log('iter,time,ribs(float),ribs,shell,stress,weight')
model = Group()
indeps = IndepVarComp()
indeps.add_output('ribs', (22 - offset_rib) / scale_rib)
indeps.add_output('shell', (0.0024 - offset_shell) / scale_shell)
model.add_subsystem('des_vars', indeps)
model.add_subsystem('wing', WingStructureSurro())
model.connect('des_vars.ribs', ['wing.ribs', 'con_cmp1.ribs'])
model.connect('des_vars.shell', 'wing.shell')
# design variables, limits and constraints
model.add_design_var('des_vars.ribs', lower=(range_rib[0] - offset_rib) / scale_rib, upper=(range_rib[1] - offset_rib) / scale_rib)
model.add_design_var('des_vars.shell', lower=(range_shell[0] - offset_shell) / scale_shell, upper=(range_shell[1] - offset_shell) / scale_shell)
# objective
model.add_objective('wing.weight', scaler=0.0001)
# constraint
print('constrain stress: ' + str((max_shear_strength - offset_stress) / scale_stress))
model.add_constraint('wing.stress', upper=(max_shear_strength - offset_stress) / scale_stress)
model.add_subsystem('con_cmp1', ExecComp('con1 = (ribs * '+str(scale_rib)+') - int(ribs[0] * '+str(scale_rib)+')'))
model.add_constraint('con_cmp1.con1', upper=.5)
prob = Problem(model)
# setup the optimization
if USE_PYOPTSPARSE:
prob.driver = pyOptSparseDriver()
prob.driver.options['optimizer'] = OPTIMIZER
prob.driver.opt_settings['SwarmSize'] = 8
prob.driver.opt_settings['stopIters'] = 5
else:
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = OPTIMIZER # ['Nelder-Mead', 'Powell', 'CG', 'BFGS', 'Newton-CG', 'L-BFGS-B', 'TNC', 'COBYLA', 'SLSQP']
prob.driver.options['tol'] = TOL
prob.driver.options['disp'] = True
prob.driver.options['maxiter'] = 1000
#prob.driver.opt_settings['etol'] = 100
prob.setup()
prob.set_solver_print(level=0)
prob.model.approx_totals()
prob.setup(check=True, mode='fwd')
prob.run_driver()
print('done')
print('ribs: ' + str((prob['wing.ribs'] * scale_rib) + offset_rib))
print('shell: ' + str((prob['wing.shell'] * scale_shell) + offset_shell) + ' m')
print('weight= ' + str((prob['wing.weight'] * scale_weight) + offset_weight))
print('stress= ' + str((prob['wing.stress'] * scale_stress) + offset_stress) + ' ~ ' + str(prob['wing.stress']))
print('execution counts wing: ' + str(prob.model.wing.executionCounter))
def setup(self):
super(VectorizedIntegrator, self).setup()
ode_function = self.options['ode_function']
method = self.options['method']
starting_coeffs = self.options['starting_coeffs']
formulation = self.options['formulation']
has_starting_method = method.starting_method is not None
is_starting_method = starting_coeffs is not None
states = ode_function._states
static_parameters = ode_function._static_parameters
dynamic_parameters = ode_function._dynamic_parameters
time_units = ode_function._time_options['units']
starting_norm_times, my_norm_times = self._get_meta()
glm_A, glm_B, glm_U, glm_V, num_stages, num_step_vars = self._get_method(
)
num_times = len(my_norm_times)
# ------------------------------------------------------------------------------------
integration_group = Group(assembled_jac_type='dense')
self.add_subsystem('integration_group', integration_group)
if formulation == 'optimizer-based':
comp = IndepVarComp()
for state_name, state in iteritems(states):
comp.add_output('Y:%s' % state_name,
shape=(
num_times - 1,
num_stages,
) + state['shape'],
units=state['units'])
comp.add_design_var('Y:%s' % state_name)
integration_group.add_subsystem('desvars_comp', comp)
elif formulation == 'solver-based':
comp = IndepVarComp()
for state_name, state in iteritems(states):
comp.add_output('Y:%s' % state_name,
val=0.,
shape=(
num_times - 1,
num_stages,
) + state['shape'],
units=state['units'])
integration_group.add_subsystem('dummy_comp', comp)
comp = self._create_ode((num_times - 1) * num_stages)
integration_group.add_subsystem('ode_comp', comp)
if ode_function._time_options['targets']:
self.connect(
'time_comp.stage_times',
[
'.'.join(('integration_group.ode_comp', t))
for t in ode_function._time_options['targets']
],
)
if len(static_parameters) > 0:
self._connect_multiple(
self._get_static_parameter_names('static_parameter_comp',
'out'),
self._get_static_parameter_names('integration_group.ode_comp',
'targets'),
[
np.array([0] * self._get_stage_norm_times(), np.int)
for _ in range(len(static_parameters))
])
if len(dynamic_parameters) > 0:
self._connect_multiple(
self._get_dynamic_parameter_names('dynamic_parameter_comp',
'out'),
self._get_dynamic_parameter_names('integration_group.ode_comp',
'targets'),
)
comp = VectorizedStageStepComp(
states=states,
time_units=time_units,
num_times=num_times,
num_stages=num_stages,
num_step_vars=num_step_vars,
glm_A=glm_A,
glm_U=glm_U,
glm_B=glm_B,
glm_V=glm_V,
)
integration_group.add_subsystem('vectorized_stagestep_comp', comp)
self.connect('time_comp.h_vec',
'integration_group.vectorized_stagestep_comp.h_vec')
comp = VectorizedStepComp(
states=states,
time_units=time_units,
num_times=num_times,
num_stages=num_stages,
num_step_vars=num_step_vars,
glm_B=glm_B,
glm_V=glm_V,
)
self.add_subsystem('vectorized_step_comp', comp)
self.connect('time_comp.h_vec', 'vectorized_step_comp.h_vec')
self._connect_multiple(
self._get_state_names('starting_system', 'starting'),
self._get_state_names(
'integration_group.vectorized_stagestep_comp', 'y0'),
)
self._connect_multiple(
self._get_state_names('starting_system', 'starting'),
self._get_state_names('vectorized_step_comp', 'y0'),
)
comp = VectorizedOutputComp(
states=states,
num_starting_times=len(starting_norm_times),
num_my_times=len(my_norm_times),
num_step_vars=num_step_vars,
starting_coeffs=starting_coeffs,
)
promotes = []
promotes.extend(
[get_name('state', state_name) for state_name in states])
if is_starting_method:
promotes.extend(
[get_name('starting', state_name) for state_name in states])
self.add_subsystem('output_comp', comp, promotes_outputs=promotes)
if has_starting_method:
self._connect_multiple(
self._get_state_names('starting_system', 'state'),
self._get_state_names('output_comp', 'starting_state'),
)
src_indices_to_ode = []
src_indices_from_ode = []
for state_name, state in iteritems(states):
size = np.prod(state['shape'])
shape = state['shape']
src_indices_to_ode.append(
np.arange(
(num_times - 1) * num_stages *
size).reshape(((num_times - 1) * num_stages, ) + shape))
src_indices_from_ode.append(
np.arange((num_times - 1) * num_stages * size).reshape((
num_times - 1,
num_stages,
) + shape))
src_indices_to_ode = [
np.array(idx).squeeze() for idx in src_indices_to_ode
]
self._connect_multiple(
self._get_state_names('vectorized_step_comp', 'y'),
self._get_state_names('output_comp', 'y'),
)
self._connect_multiple(
self._get_state_names('integration_group.ode_comp', 'rate_source'),
self._get_state_names('vectorized_step_comp', 'F'),
src_indices_from_ode,
)
self._connect_multiple(
self._get_state_names('integration_group.ode_comp', 'rate_source'),
self._get_state_names(
'integration_group.vectorized_stagestep_comp', 'F'),
src_indices_from_ode,
)
if formulation == 'solver-based':
self._connect_multiple(
self._get_state_names(
'integration_group.vectorized_stagestep_comp', 'Y_out'),
self._get_state_names('integration_group.ode_comp', 'targets'),
src_indices_to_ode,
)
self._connect_multiple(
self._get_state_names('integration_group.dummy_comp', 'Y'),
self._get_state_names(
'integration_group.vectorized_stagestep_comp', 'Y_in'),
)
elif formulation == 'optimizer-based':
self._connect_multiple(
self._get_state_names('integration_group.desvars_comp', 'Y'),
self._get_state_names('integration_group.ode_comp', 'targets'),
src_indices_to_ode,
)
self._connect_multiple(
self._get_state_names('integration_group.desvars_comp', 'Y'),
self._get_state_names(
'integration_group.vectorized_stagestep_comp', 'Y_in'),
)
for state_name, state in iteritems(states):
integration_group.add_constraint(
'vectorized_stagestep_comp.Y_out:%s' % state_name,
equals=0.,
vectorize_derivs=True,
)
if has_starting_method:
self.starting_system.options['formulation'] = self.options[
'formulation']
if formulation == 'solver-based':
if 1:
integration_group.nonlinear_solver = NonlinearBlockGS(
iprint=2, maxiter=40, atol=1e-14, rtol=1e-12)
else:
integration_group.nonlinear_solver = NewtonSolver(iprint=2,
maxiter=100)
if 1:
integration_group.linear_solver = LinearBlockGS(iprint=1,
maxiter=40,
atol=1e-14,
rtol=1e-12)
else:
integration_group.linear_solver = DirectSolver(
assemble_jac=True, iprint=1)
model.connect('CT1Comp.CT1','ATComp.CT1')
model.connect('CT2Comp.CT2','ATComp.CT2')
model.add_subsystem('VelocityComp',VelocityComp(num_panel=airfoil.NUM_SAMPLES,aoa=airfoil.aoa))
model.connect('GammaComp.gamma','VelocityComp.gamma')
model.connect('thetaComp.theta','VelocityComp.theta')
model.connect('ATComp.AT','VelocityComp.AT')
model.add_subsystem('LiftComp',LiftComp(num_panel=airfoil.NUM_SAMPLES))
model.connect('VelocityComp.V','LiftComp.V')
model.connect('arcComp.S','LiftComp.S')
model.add_design_var('input.y')
model.add_objective('LiftComp.CL')
leftmost_id = int(airfoil.NUM_SAMPLES/2)
model.add_constraint('input.y',indices=[0,leftmost_id,-1],equals=[airfoil.boundaryPoints_Y[0],airfoil.boundaryPoints_Y[leftmost_id],airfoil.boundaryPoints_Y[-1]])
prob = Problem(model=model)
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['maxiter'] = 300
prob.driver.options['tol'] = 1e-6
prob.set_solver_print(level=0)
prob.model.approx_totals()
prob.setup()
prob.run_driver()
airfoil.Get_PanelCoefficients()
print(airfoil.full_coefficientLift)
group.add_subsystem('vx_comp', ExecComp('vx = v * cos(theta)'))
group.add_subsystem('vy_comp', ExecComp('vy = v * sin(theta)'))
group.add_subsystem('integrator_group', integrator)
group.connect('final_time_comp.final_time', 'integrator_group.final_time')
group.connect('theta_comp.theta', 'vx_comp.theta')
group.connect('theta_comp.theta', 'vy_comp.theta')
group.connect('v_comp.v', 'vx_comp.v')
group.connect('v_comp.v', 'vy_comp.v')
group.connect('vx_comp.vx', 'integrator_group.initial_condition:vx')
group.connect('vy_comp.vy', 'integrator_group.initial_condition:vy')
group.add_design_var('final_time_comp.final_time', lower=1e-3)
group.add_design_var('theta_comp.theta', lower=0., upper=np.pi / 2.)
group.add_constraint('integrator_group.state:y', indices=[-1], equals=0.)
group.add_objective('integrator_group.state:x', index=-1, scaler=-1.)
prob = Problem()
prob.model = group
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
# from openmdao.api import pyOptSparseDriver
# prob.driver = driver = pyOptSparseDriver()
# driver.options['optimizer'] = 'SNOPT'
# driver.opt_settings['Verify level'] = 0
# driver.opt_settings['Major iterations limit'] = 200 #1000
# driver.opt_settings['Minor iterations limit'] = 1000
# driver.opt_settings['Iterations limit'] = 100000
# driver.opt_settings['Major step limit'] = 2.0
