def runOpenMdaoDEP():
prob = Problem()
#first guesses here
indeps = prob.model.add_subsystem('indeps', IndepVarComp(), promotes=['*'])
# load defaults from BPAirfoil
bp = BPAirfoil()
# read last optimization result if available (has to be copied here manually)
if os.path.isfile(INPUT_DIR+'/'+'airfoil.txt'):
bp.read_parameters_from_file(INPUT_DIR+'/'+'airfoil.txt')
indeps.add_output('r_le', bp.r_le)
indeps.add_output('beta_te', bp.beta_te)
indeps.add_output('x_t', bp.x_t)
indeps.add_output('gamma_le', bp.gamma_le)
indeps.add_output('x_c', bp.x_c)
indeps.add_output('y_c', bp.y_c)
indeps.add_output('alpha_te', bp.alpha_te)
#indeps.add_output('z_te', bp.z_te)
indeps.add_output('b_8', bp.b_8)
indeps.add_output('b_15', bp.b_15)
indeps.add_output('b_0', bp.b_0)
indeps.add_output('b_2', bp.b_2)
indeps.add_output('b_17', bp.b_17)
prob.model.add_subsystem('airfoil_cfd', AirfoilCFD())
prob.model.connect('r_le', 'airfoil_cfd.r_le')
prob.model.connect('beta_te', 'airfoil_cfd.beta_te')
prob.model.connect('x_t', 'airfoil_cfd.x_t')
prob.model.connect('gamma_le', 'airfoil_cfd.gamma_le')
prob.model.connect('x_c', 'airfoil_cfd.x_c')
prob.model.connect('y_c', 'airfoil_cfd.y_c')
prob.model.connect('alpha_te', 'airfoil_cfd.alpha_te')
#prob.model.connect('z_te', 'airfoil_cfd.z_te')
prob.model.connect('b_8', 'airfoil_cfd.b_8')
prob.model.connect('b_15', 'airfoil_cfd.b_15')
prob.model.connect('b_0', 'airfoil_cfd.b_0')
prob.model.connect('b_2', 'airfoil_cfd.b_2')
prob.model.connect('b_17', 'airfoil_cfd.b_17')
# setup the optimization
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1e-6
prob.driver.options['maxiter'] = 100000
# setup recorder
recorder = SqliteRecorder(WORKING_DIR + '/openMdaoLog.sql')
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_responses'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
#limits and constraints
prob.model.add_design_var('r_le', upper=0.)#, lower=-1*bp.y_t, upper=0)
prob.model.add_design_var('beta_te')#, lower=bp.beta_te*lowerPro, upper=bp.beta_te*upperPro)
#prob.model.add_design_var('dz_te', lower=0., upper=0.)
prob.model.add_design_var('x_t', lower=0.)#, lower=0.25, upper=0.5)
#prob.model.add_design_var('y_t')#, lower=0.075, upper=0.09)
prob.model.add_design_var('gamma_le')#, lower=bp.gamma_le*lowerPro, upper=bp.gamma_le*upperPro)
prob.model.add_design_var('x_c')#, lower=bp.x_c*lowerPro, upper=bp.x_c*upperPro)
prob.model.add_design_var('y_c')#, lower=bp.y_c*lowerPro, upper=bp.y_c*upperPro)
prob.model.add_design_var('alpha_te')#, lower=bp.alpha_te*upperPro, upper=bp.alpha_te*lowerPro)
#prob.model.add_design_var('z_te')#, lower=0., upper=0.)
prob.model.add_design_var('b_8')#, lower=bp.b_8*lowerPro, upper=bp.b_8*upperPro)
prob.model.add_design_var('b_15')#, lower=bp.b_15*lowerPro, upper=bp.b_15*upperPro)
prob.model.add_design_var('b_0')#, lower=bp.b_0*lowerPro, upper=bp.b_0*upperPro)
prob.model.add_design_var('b_2')#, lower=bp.b_2*lowerPro, upper=bp.b_2*upperPro)
prob.model.add_design_var('b_17')#, lower=bp.b_17*lowerPro, upper=bp.b_17*upperPro)
prob.model.add_objective('airfoil_cfd.c_d', scaler=1)
prob.model.add_constraint('airfoil_cfd.cabin_height', lower=cabinHeigth * 0.99, upper=cabinHeigth*1.05)
prob.model.add_constraint('airfoil_cfd.c_l', lower=0.145, upper=.155)
prob.model.add_constraint('airfoil_cfd.c_m', lower=-0.05, upper=99.)
write_to_log('iterations,time,c_l,c_d,c_m,CL/CD,cfdIterations,cabin_height,offsetFront,angle,r_le,beta_te,x_t,y_t,gamma_le,x_c,y_c,alpha_te,z_te,b_8,b_15,b_0,b_17,b_2]))')
prob.setup()
prob.set_solver_print(level=0)
prob.model.approx_totals()
prob.run_driver()
print('done')
print('cabin frontOffset: ' + str(prob['airfoil_cfd.offsetFront']))
print('cabin angle: ' + str(-1. * prob['airfoil_cfd.angle']) + ' deg')
print('c_l= ' + str(prob['airfoil_cfd.c_l']))
print('c_d= ' + str(prob['airfoil_cfd.c_d']))
print('c_m= ' + str(prob['airfoil_cfd.c_m']))
print('execution counts airfoil cfd: ' + str(prob.model.airfoil_cfd.executionCounter))
# Tower
# prob.model.add_constraint('tow.height_constraint', lower=-1e-2,upper=1.e-2)
# prob.model.add_constraint('tow.post.stress', upper=1.0)
# prob.model.add_constraint('tow.post.global_buckling', upper=1.0)
# prob.model.add_constraint('tow.post.shell_buckling', upper=1.0)
# prob.model.add_constraint('tow.weldability', upper=0.0)
# prob.model.add_constraint('tow.manufacturability', lower=0.0)
# prob.model.add_constraint('frequencyNP_margin', upper=0.)
# prob.model.add_constraint('frequency1P_margin', upper=0.)
# prob.model.add_constraint('ground_clearance', lower=20.0)
# ----------------------
# --- Recorder ---
filename_opt_log = folder_output + os.sep + 'log_opt_' + blade['config']['name']
prob.driver.add_recorder(SqliteRecorder(filename_opt_log))
prob.driver.recording_options['includes'] = ['AEP','total_blade_cost','lcoe','tip_deflection_ratio']
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['record_desvars'] = True
# ----------------------
# --- Run ---
prob.setup()
prob = Init_MonopileTurbine(prob, blade, Nsection_Tow = Nsection_Tow)
prob['drive.shaft_angle'] = np.radians(6.)
prob['overhang'] = 8.5
prob['drive.distance_hub2mb'] = 3.5
prob['significant_wave_height'] = 4.52
prob['significant_wave_period'] = 9.45
prob['monopile'] = True
def test(self):
# Create a dictionary to store options about the surface
mesh_dict = {
'num_y': 7,
'num_x': 3,
'wing_type': 'uCRM_based',
'symmetry': True,
'chord_cos_spacing': 0,
'span_cos_spacing': 0,
'num_twist_cp': 6,
}
mesh, twist_cp = generate_mesh(mesh_dict)
surf_dict = {
# Wing definition
'name':
'wing', # name of the surface
'symmetry':
True, # if true, model one half of wing
'S_ref_type':
'wetted', # how we compute the wing area,
# can be 'wetted' or 'projected'
'mesh':
mesh,
'twist_cp':
np.array([4., 5., 8., 8., 8., 9.]),
'fem_model_type':
'wingbox',
'data_x_upper':
upper_x,
'data_x_lower':
lower_x,
'data_y_upper':
upper_y,
'data_y_lower':
lower_y,
'spar_thickness_cp':
np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]), # [m]
'skin_thickness_cp':
np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
'original_wingbox_airfoil_t_over_c':
0.12,
# Aerodynamic deltas.
# These CL0 and CD0 values are added to the CL and CD
# obtained from aerodynamic analysis of the surface to get
# the total CL and CD.
# These CL0 and CD0 values do not vary wrt alpha.
# They can be used to account for things that are not included, such as contributions from the fuselage, nacelles, tail surfaces, etc.
'CL0':
0.0,
'CD0':
0.0078,
'with_viscous':
True, # if true, compute viscous drag
'with_wave':
True, # if true, compute wave drag
# Airfoil properties for viscous drag calculation
'k_lam':
0.05, # percentage of chord with laminar
# flow, used for viscous drag
'c_max_t':
.38, # chordwise location of maximum thickness
't_over_c_cp':
np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
# Structural values are based on aluminum 7075
'E':
73.1e9, # [Pa] Young's modulus
'G': (
73.1e9 / 2 / 1.33
), # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
'yield': (420.e6 / 1.5), # [Pa] allowable yield stress
'mrho':
2.78e3, # [kg/m^3] material density
'strength_factor_for_upper_skin':
1.0, # the yield stress is multiplied by this factor for the upper skin
'wing_weight_ratio':
1.25,
'exact_failure_constraint':
False, # if false, use KS function
'struct_weight_relief':
True,
'distributed_fuel_weight':
True,
'fuel_density':
803., # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
'Wf_reserve':
15000., # [kg] reserve fuel mass
}
surfaces = [surf_dict]
# Create the problem and assign the model group
prob = Problem()
# Add problem information as an independent variables component
indep_var_comp = IndepVarComp()
indep_var_comp.add_output('v',
val=np.array([.85 * 295.07, .64 * 340.294]),
units='m/s')
indep_var_comp.add_output('alpha', val=0., units='deg')
indep_var_comp.add_output('alpha_maneuver', val=0., units='deg')
indep_var_comp.add_output('Mach_number', val=np.array([0.85, 0.64]))
indep_var_comp.add_output('re',val=np.array([0.348*295.07*.85*1./(1.43*1e-5), \
1.225*340.294*.64*1./(1.81206*1e-5)]), units='1/m')
indep_var_comp.add_output('rho',
val=np.array([0.348, 1.225]),
units='kg/m**3')
indep_var_comp.add_output('CT', val=0.53 / 3600, units='1/s')
indep_var_comp.add_output('R', val=14.307e6, units='m')
indep_var_comp.add_output('W0',
val=148000 + surf_dict['Wf_reserve'],
units='kg')
indep_var_comp.add_output('speed_of_sound',
val=np.array([295.07, 340.294]),
units='m/s')
indep_var_comp.add_output('load_factor', val=np.array([1., 2.5]))
indep_var_comp.add_output('empty_cg', val=np.zeros((3)), units='m')
indep_var_comp.add_output('fuel_mass', val=10000., units='kg')
prob.model.add_subsystem('prob_vars', indep_var_comp, promotes=['*'])
# Loop over each surface in the surfaces list
for surface in surfaces:
# Get the surface name and create a group to contain components
# only for this surface
name = surface['name']
aerostruct_group = AerostructGeometry(surface=surface)
# Add group to the problem with the name of the surface.
prob.model.add_subsystem(name, aerostruct_group)
# Loop through and add a certain number of aerostruct points
for i in range(2):
point_name = 'AS_point_{}'.format(i)
# Connect the parameters within the model for each aerostruct point
# Create the aero point group and add it to the model
AS_point = AerostructPoint(surfaces=surfaces,
internally_connect_fuelburn=False)
prob.model.add_subsystem(point_name, AS_point)
# Connect flow properties to the analysis point
prob.model.connect('v', point_name + '.v', src_indices=[i])
prob.model.connect('Mach_number',
point_name + '.Mach_number',
src_indices=[i])
prob.model.connect('re', point_name + '.re', src_indices=[i])
prob.model.connect('rho', point_name + '.rho', src_indices=[i])
prob.model.connect('CT', point_name + '.CT')
prob.model.connect('R', point_name + '.R')
prob.model.connect('W0', point_name + '.W0')
prob.model.connect('speed_of_sound',
point_name + '.speed_of_sound',
src_indices=[i])
prob.model.connect('empty_cg', point_name + '.empty_cg')
prob.model.connect('load_factor',
point_name + '.load_factor',
src_indices=[i])
prob.model.connect('fuel_mass',
point_name + '.total_perf.L_equals_W.fuelburn')
prob.model.connect('fuel_mass',
point_name + '.total_perf.CG.fuelburn')
for surface in surfaces:
name = surface['name']
if surf_dict['distributed_fuel_weight']:
prob.model.connect('load_factor',
point_name + '.coupled.load_factor',
src_indices=[i])
com_name = point_name + '.' + name + '_perf.'
prob.model.connect(
name + '.local_stiff_transformed', point_name +
'.coupled.' + name + '.local_stiff_transformed')
prob.model.connect(name + '.nodes',
point_name + '.coupled.' + name + '.nodes')
# Connect aerodyamic mesh to coupled group mesh
prob.model.connect(name + '.mesh',
point_name + '.coupled.' + name + '.mesh')
if surf_dict['struct_weight_relief']:
prob.model.connect(
name + '.element_mass',
point_name + '.coupled.' + name + '.element_mass')
# Connect performance calculation variables
prob.model.connect(name + '.nodes', com_name + 'nodes')
prob.model.connect(
name + '.cg_location',
point_name + '.' + 'total_perf.' + name + '_cg_location')
prob.model.connect(
name + '.structural_mass', point_name + '.' +
'total_perf.' + name + '_structural_mass')
# Connect wingbox properties to von Mises stress calcs
prob.model.connect(name + '.Qz', com_name + 'Qz')
prob.model.connect(name + '.J', com_name + 'J')
prob.model.connect(name + '.A_enc', com_name + 'A_enc')
prob.model.connect(name + '.htop', com_name + 'htop')
prob.model.connect(name + '.hbottom', com_name + 'hbottom')
prob.model.connect(name + '.hfront', com_name + 'hfront')
prob.model.connect(name + '.hrear', com_name + 'hrear')
prob.model.connect(name + '.spar_thickness',
com_name + 'spar_thickness')
prob.model.connect(name + '.t_over_c', com_name + 't_over_c')
prob.model.connect('alpha', 'AS_point_0' + '.alpha')
prob.model.connect('alpha_maneuver', 'AS_point_1' + '.alpha')
# Here we add the fuel volume constraint componenet to the model
prob.model.add_subsystem('fuel_vol_delta',
WingboxFuelVolDelta(surface=surface))
prob.model.connect('wing.struct_setup.fuel_vols',
'fuel_vol_delta.fuel_vols')
prob.model.connect('AS_point_0.fuelburn', 'fuel_vol_delta.fuelburn')
if surf_dict['distributed_fuel_weight']:
prob.model.connect(
'wing.struct_setup.fuel_vols',
'AS_point_0.coupled.wing.struct_states.fuel_vols')
prob.model.connect(
'fuel_mass', 'AS_point_0.coupled.wing.struct_states.fuel_mass')
prob.model.connect(
'wing.struct_setup.fuel_vols',
'AS_point_1.coupled.wing.struct_states.fuel_vols')
prob.model.connect(
'fuel_mass', 'AS_point_1.coupled.wing.struct_states.fuel_mass')
comp = ExecComp('fuel_diff = (fuel_mass - fuelburn) / fuelburn',
units='kg')
prob.model.add_subsystem('fuel_diff',
comp,
promotes_inputs=['fuel_mass'],
promotes_outputs=['fuel_diff'])
prob.model.connect('AS_point_0.fuelburn', 'fuel_diff.fuelburn')
## Use these settings if you do not have pyOptSparse or SNOPT
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1e-8
recorder = SqliteRecorder("unit_test.db")
prob.driver.add_recorder(recorder)
# We could also just use prob.driver.recording_options['includes']=['*'] here, but for large meshes the database file becomes extremely large. So we just select the variables we need.
prob.driver.recording_options['includes'] = [
'alpha',
'rho',
'v',
'cg',
'AS_point_1.cg',
'AS_point_0.cg',
'AS_point_0.coupled.wing_loads.loads',
'AS_point_1.coupled.wing_loads.loads',
'AS_point_0.coupled.wing.normals',
'AS_point_1.coupled.wing.normals',
'AS_point_0.coupled.wing.widths',
'AS_point_1.coupled.wing.widths',
'AS_point_0.coupled.aero_states.wing_sec_forces',
'AS_point_1.coupled.aero_states.wing_sec_forces',
'AS_point_0.wing_perf.CL1',
'AS_point_1.wing_perf.CL1',
'AS_point_0.coupled.wing.S_ref',
'AS_point_1.coupled.wing.S_ref',
'wing.geometry.twist',
'wing.mesh',
'wing.skin_thickness',
'wing.spar_thickness',
'wing.t_over_c',
'wing.structural_mass',
'AS_point_0.wing_perf.vonmises',
'AS_point_1.wing_perf.vonmises',
'AS_point_0.coupled.wing.def_mesh',
'AS_point_1.coupled.wing.def_mesh',
]
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_inputs'] = True
prob.model.add_objective('AS_point_0.fuelburn', scaler=1e-5)
prob.model.add_design_var('wing.twist_cp',
lower=-15.,
upper=15.,
scaler=0.1)
prob.model.add_design_var('wing.spar_thickness_cp',
lower=0.003,
upper=0.1,
scaler=1e2)
prob.model.add_design_var('wing.skin_thickness_cp',
lower=0.003,
upper=0.1,
scaler=1e2)
prob.model.add_design_var('wing.geometry.t_over_c_cp',
lower=0.07,
upper=0.2,
scaler=10.)
prob.model.add_design_var('fuel_mass',
lower=0.,
upper=2e5,
scaler=1e-5)
prob.model.add_design_var('alpha_maneuver', lower=-15., upper=15)
prob.model.add_constraint('AS_point_0.CL', equals=0.5)
prob.model.add_constraint('AS_point_1.L_equals_W', equals=0.)
prob.model.add_constraint('AS_point_1.wing_perf.failure', upper=0.)
prob.model.add_constraint('fuel_vol_delta.fuel_vol_delta', lower=0.)
prob.model.add_constraint('fuel_diff', equals=0.)
# Set up the problem
prob.setup()
prob.run_driver()
# print(prob['AS_point_0.fuelburn'][0])
# print(prob['wing.structural_mass'][0]/surf_dict['wing_weight_ratio'])
# print(prob['wing.geometry.t_over_c_cp'])
assert_rel_error(self, prob['AS_point_0.fuelburn'][0], 101937.827384,
1e-5)
assert_rel_error(
self,
prob['wing.structural_mass'][0] / surf_dict['wing_weight_ratio'],
36539.6437566, 1e-5)
assert_rel_error(
self, prob['wing.geometry.t_over_c_cp'],
np.array([
0.10247881, 0.08207636, 0.11114547, 0.13114547, 0.10207636,
0.09365598
]), 1e-5)
def setup_energy_opt(num_seg,
order,
Q_env=0.,
Q_sink=0.,
Q_out=0.,
m_flow=0.1,
m_burn=0.,
opt_m_flow=False,
opt_m_burn=False):
"""
Helper function to set up and return a problem instance for an energy minimization
of a simple thermal system.
Parameters
----------
num_seg : int
The number of ODE segments to use when discretizing the problem.
order : int
The order for the polynomial interpolation for the collocation methods.
"""
# Instantiate the problem and set the optimizer
p = Problem(model=Group())
p.driver = pyOptSparseDriver()
p.driver.options['optimizer'] = 'SNOPT'
p.driver.opt_settings['Major iterations limit'] = 2000
p.driver.opt_settings['Major feasibility tolerance'] = 1.0E-7
p.driver.opt_settings['Major optimality tolerance'] = 1.0E-7
p.driver.opt_settings['Verify level'] = -1
# Set up the phase for the defined ODE function, can be LGR or LGL
phase = Phase('gauss-lobatto',
ode_class=TankAloneODE,
ode_init_kwargs={},
num_segments=num_seg,
transcription_order=order,
compressed=True)
# Do not allow the time to vary during the optimization
phase.set_time_options(opt_initial=False, opt_duration=False)
# Set the state options for mass, temperature, and energy.
phase.set_state_options('m', lower=1., upper=10., fix_initial=False)
phase.set_state_options('T', fix_initial=True)
phase.set_state_options('energy', fix_initial=True)
# Minimize the energy used to pump the fuel
# phase.add_objective('energy', loc='final')
# phase.add_objective('m', loc='initial')
phase.add_objective('time', loc='final')
# Allow the optimizer to vary the fuel flow
if opt_m_flow:
phase.add_control('m_flow',
val=m_flow,
lower=0.01,
opt=True,
rate_continuity=True)
else:
phase.add_control('m_flow', val=m_flow, opt=False)
if opt_m_burn:
phase.add_control('m_burn',
val=m_burn,
lower=0.01,
opt=True,
rate_continuity=True)
else:
phase.add_control('m_burn', val=m_burn, opt=False)
phase.add_control('Q_env', val=Q_env, dynamic=False, opt=False)
phase.add_control('Q_sink', val=Q_sink, dynamic=False, opt=False)
phase.add_control('Q_out', val=Q_out, dynamic=False, opt=False)
# Constrain the temperature, 2nd derivative of fuel mass in the tank, and make
# sure that the amount recirculated is at least 0, otherwise we'd burn
# more fuel than we pumped.
if opt_m_flow:
phase.add_path_constraint('T', upper=1.)
phase.add_path_constraint('m_flow_rate', upper=0.)
phase.add_path_constraint('m_recirculated', lower=0.)
phase.add_path_constraint('m_flow', upper=3.)
# Add the phase to the problem and set it up
p.model.add_subsystem('phase', phase)
p.driver.add_recorder(SqliteRecorder('out.db'))
p.setup(check=True, force_alloc_complex=True, mode='fwd')
# Give initial values for the phase states, controls, and time
p['phase.states:m'] = 2.
p['phase.states:T'] = 1.
p['phase.states:energy'] = 0.
p['phase.t_initial'] = 0.
p['phase.t_duration'] = 10.
p.set_solver_print(level=-1)
return p
top.driver.add_constraint('con_m_l', lower=0., scaler=1/scaled_mass)
for i in range(N):
top.driver.add_constraint('delta_omega_u_'+str(i+1), upper=0., scaler=1/np.sqrt(eigval_ref[i]))
for i in range(N):
top.driver.add_constraint('delta_omega_l_'+str(i+1), lower=0., scaler=1/np.sqrt(eigval_ref[i]))
for i in range(tn):
top.driver.add_constraint('t_l_'+str(i+1), lower=0., scaler=1/t_0[i])
for i in range(mn):
top.driver.add_constraint('m_l_'+str(i+1), lower=0., scaler=1/m_0[i])
#Optimization Recorder
recorder = SqliteRecorder('modal_optim_COBYLA_GARTEUR')
recorder.options['record_params'] = True
recorder.options['record_metadata'] = True
top.driver.add_recorder(recorder)
top.setup()
view_model(top, show_browser=False)
#Setting initial values for design variables
top['t'] = t_0
top['m'] = m_0
# top['t'] = np.array([50.,11.,10.,10.,10.,10.])
# top['m'] = np.array([0.5,0.2,0.2])
top.run()
prob.model.add_constraint('tow.post.stress', upper=1.0)
prob.model.add_constraint('tow.post.global_buckling', upper=1.0)
prob.model.add_constraint('tow.post.shell_buckling', upper=1.0)
prob.model.add_constraint('tow.weldability', upper=0.0)
prob.model.add_constraint('tow.manufacturability', lower=0.0)
# prob.model.add_constraint('frequency1P_margin_low', upper=1.0)
# prob.model.add_constraint('frequency1P_margin_high', lower=1.0)
# prob.model.add_constraint('frequencyNP_margin_low', upper=1.0)
# prob.model.add_constraint('frequencyNP_margin_high', lower=1.0)
prob.model.add_constraint('frequencyNP_margin', upper=0.)
prob.model.add_constraint('frequency1P_margin', upper=0.)
prob.model.add_constraint('ground_clearance', lower=20.0)
# ----------------------
# --- Recorder ---
prob.driver.add_recorder(SqliteRecorder('log_opt.sql'))
prob.driver.recording_options['includes'] = [
'AEP', 'rc.total_blade_cost', 'lcoe', 'tip_deflection_ratio'
]
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['record_desvars'] = True
# ----------------------
prob.setup(check=True)
prob = Init_LandBasedAssembly(prob, blade, Nsection_Tow)
prob.model.nonlinear_solver = NonlinearRunOnce()
prob.model.linear_solver = DirectSolver()
if not MPI:
prob.model.add_constraint('con_esf', upper=0.0)
prob.model.add_constraint('con_temp', upper=0.0)
#Coupling constraints
#Threshold for the coupling (constraints define as (x_in-x_out)**2<epsilon)
epsilon=1e-10
prob.model.add_constraint('con_str_aer_wt',upper=epsilon)
prob.model.add_constraint('con_str_aer_theta',upper=epsilon)
prob.model.add_constraint('con_aer_str_l',upper=epsilon)
prob.model.add_constraint('con_aer_pro_d',upper=epsilon)
prob.model.add_constraint('con_pro_aer_esf',upper=epsilon)
prob.model.add_constraint('con_pro_str_we',upper=epsilon)
#Recorder
db_name = 'ssbj_idf.sqlite'
if "--plot" in argv:
recorder = SqliteRecorder(db_name)
# recorder2 = WebRecorder("", case_name="SSBJ IDF")
prob.driver.recording_options['record_desvars'] = True
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.add_recorder(recorder)
# prob.driver.add_recorder(recorder2)
#Run optimization
prob.setup(mode='fwd')
prob.run_driver()
#prob.run_model()
#prob.check_partials()
#prob.cleanup()
print('Z_opt=', prob['z']*scalers['z'])
prob = Problem()
prob.root = root
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['disp'] = True
# prob.driver.options['tol'] = 1.0e-12
prob.driver.add_desvar('t',
lower=numpy.ones((num_y)) * 0.001,
upper=numpy.ones((num_y)) * 0.25)
prob.driver.add_objective('energy')
prob.driver.add_constraint('weight', upper=1e5)
prob.root.deriv_options['type'] = 'cs'
prob.root.deriv_options['form'] = 'central'
prob.root.deriv_options['step_size'] = 1e-10
prob.driver.add_recorder(SqliteRecorder('spatialbeam.db'))
prob.setup()
view_tree(prob, outfile="prob1.html", show_browser=False)
# prob.run_once()
# prob.check_partial_derivatives(compact_print=True)
st = time.time()
prob.run()
print "run time", time.time() - st
def omdaoGroup(record):
print 'Executing multiple instances of OpenMDAO-defined FAST components in parallel'
print ''
# Parallel execution entails additional dependencies--be sure they are installed
# If example = 3, be sure to run callv8Wrapper using RunParallel script file
# or using equivalent mpi commands, otherwise cases will fun in serial.
# Imports
from runFAST_v8 import runFAST_v8
from openmdao.api import Group, Problem, Component, IndepVarComp
from openmdao.api import ParallelGroup, ParallelFDGroup
from openmdao.core.mpi_wrap import MPI
if MPI:
from openmdao.core.petsc_impl import PetscImpl as impl
else:
from openmdao.core.basic_impl import BasicImpl as impl
from FASTv8_aeroelasticsolver import FASTv8_Workflow, FASTv8_AeroElasticSolver
# Initial OpenMDAO problem setup for parallel group
top = Problem(impl=impl, root=ParallelFDGroup(1)) # use for parallel
root = top.root
# Setup input config dictionary of dictionaries.
caseids = [
'omdaoParallelCase1', 'omdaoParallelCase2', 'omdaoParallelCase3',
'omdaoParallelCase4'
]
DT = [
0.01, 0.02, 0.025, 0.03
] #multiple timestep sizes we wish to test--currently limited to even multiples of TMax
cfg_master = {} #master config dictionary (dictionary of dictionaries)
for i in range(4):
# Create dictionary for this particular case
cfg = {}
cfg['DT'] = DT[i]
cfg['TMax'] = 60
# fst_exe, fst_file, fst_dir same for all cases
cfg['fst_exe'] = "../../../FAST_v8/bin/FAST_glin64"
cfg['fst_dir'] = "TemplateTest/"
cfg['fst_file'] = "Test18_.fst"
# Put dictionary into master dictionary, keyed by caseid
cfg_master[caseids[i]] = cfg
# Add parallel group to omdao problem, pass in master config file
root.add('FASTcases', FASTv8_AeroElasticSolver(cfg_master, caseids))
# Set up recorder if desired (requires sqlite)
if record:
from openmdao.api import SqliteRecorder
recorder = SqliteRecorder('omdaoparallel.sqlite')
top.driver.add_recorder(recorder)
top.setup()
top.run()
top.cleanup() #Good practice, especially when using recorder
top.driver.options['optimizer'] = 'SLSQP'
top.driver.options['tol'] = 1.0e-8
# This is for testing with SNOPT via pyOptSparse
'''
from openmdao.api import pyOptSparseDriver
top.driver = pyOptSparseDriver()
top.driver.options['optimizer'] = 'SNOPT'
'''
top.driver.add_desvar('z', lower=np.array([-10.0, 0.0]),
upper=np.array([10.0, 10.0]))
top.driver.add_desvar('x', lower=0.0, upper=10.0)
top.driver.add_objective('obj')
top.driver.add_constraint('con1', upper=0.0)
top.driver.add_constraint('con2', upper=0.0)
rec = SqliteRecorder('sellar_snopt.db')
top.driver.add_recorder(rec)
rec.options['record_derivs'] = True
top.setup()
top.run()
print("\n")
print( "Minimum found at (%f, %f, %f)" % (top['z'][0],
top['z'][1],
top['x']))
print("Coupling vars: %f, %f" % (top['y1'], top['y2']))
print("Minimum objective: ", top['obj'])
mda.nl_solver = NLGaussSeidel()
# mda.nl_solver.options['rtol'] = 1.e-1
mda.nl_solver.options['maxiter'] = 15
mda.nl_solver.options['rutol'] = 1.e-2
mda.nl_solver.options['use_aitken'] = True
mda.nl_solver.options['aitken_alpha_min'] = 0.1
mda.nl_solver.options['aitken_alpha_max'] = 1.5
mda.ln_solver = ScipyGMRES()
root.add('mda_group', mda, promotes=['*'])
top.root.mda_group.deriv_options['type'] = 'fd'
top.root.mda_group.deriv_options['step_size'] = 1.0e-1
#Recorder
recorder = SqliteRecorder('opti_g_11')
recorder.options['record_params'] = False
recorder.options['record_metadata'] = False
recorder.options['record_resids'] = False
recorder.options['record_derivs'] = False
top.root.nl_solver.add_recorder(recorder)
# top.root.add_recorder(recorder)
#Define solver type
root.add('obj_function', ExecComp('obj_f = mass'), promotes=['*'])
t_max=0.01*np.ones(tn)
t_min=0.006*np.ones(tn)
def setUpClass(cls):
cls.traj = Trajectory()
p = cls.p = Problem(model=cls.traj)
# Since we're only testing features like get_values that don't rely on a converged
# solution, no driver is attached. We'll just invoke run_model.
# First Phase (burn)
burn1 = Phase(ode_class=FiniteBurnODE, transcription=GaussLobatto(num_segments=4, order=3))
cls.traj.add_phase('burn1', burn1)
burn1.set_time_options(fix_initial=True, duration_bounds=(.5, 10))
burn1.set_state_options('r', fix_initial=True, fix_final=False)
burn1.set_state_options('theta', fix_initial=True, fix_final=False)
burn1.set_state_options('vr', fix_initial=True, fix_final=False, defect_scaler=0.1)
burn1.set_state_options('vt', fix_initial=True, fix_final=False, defect_scaler=0.1)
burn1.set_state_options('accel', fix_initial=True, fix_final=False)
burn1.set_state_options('deltav', fix_initial=True, fix_final=False)
burn1.add_control('u1', rate_continuity=True, rate2_continuity=True, units='deg')
burn1.add_design_parameter('c', opt=False, val=1.5)
# Second Phase (Coast)
coast = Phase(ode_class=FiniteBurnODE, transcription=GaussLobatto(num_segments=10, order=3))
cls.traj.add_phase('coast', coast)
coast.set_time_options(initial_bounds=(0.5, 20), duration_bounds=(.5, 10))
coast.set_state_options('r', fix_initial=False, fix_final=False)
coast.set_state_options('theta', fix_initial=False, fix_final=False)
coast.set_state_options('vr', fix_initial=False, fix_final=False)
coast.set_state_options('vt', fix_initial=False, fix_final=False)
coast.set_state_options('accel', fix_initial=True, fix_final=True)
coast.set_state_options('deltav', fix_initial=False, fix_final=False)
coast.add_control('u1', opt=False, val=0.0, units='deg')
coast.add_design_parameter('c', opt=False, val=1.5)
# Third Phase (burn)
burn2 = Phase(ode_class=FiniteBurnODE, transcription=GaussLobatto(num_segments=3, order=3))
cls.traj.add_phase('burn2', burn2)
burn2.set_time_options(initial_bounds=(0.5, 20), duration_bounds=(.5, 10))
burn2.set_state_options('r', fix_initial=False, fix_final=True, defect_scaler=1.0)
burn2.set_state_options('theta', fix_initial=False, fix_final=False, defect_scaler=1.0)
burn2.set_state_options('vr', fix_initial=False, fix_final=True, defect_scaler=0.1)
burn2.set_state_options('vt', fix_initial=False, fix_final=True, defect_scaler=0.1)
burn2.set_state_options('accel', fix_initial=False, fix_final=False, defect_scaler=1.0)
burn2.set_state_options('deltav', fix_initial=False, fix_final=False, defect_scaler=1.0)
burn2.add_control('u1', rate_continuity=True, rate2_continuity=True, units='deg',
ref0=0, ref=10)
burn2.add_design_parameter('c', opt=False, val=1.5)
burn2.add_objective('deltav', loc='final')
# Link Phases
cls.traj.link_phases(phases=['burn1', 'coast', 'burn2'],
vars=['time', 'r', 'theta', 'vr', 'vt', 'deltav'])
cls.traj.link_phases(phases=['burn1', 'burn2'], vars=['accel'])
# Finish Problem Setup
p.model.linear_solver = DirectSolver()
p.model.add_recorder(SqliteRecorder('test_trajectory_rec.db'))
p.setup(check=True)
# Set Initial Guesses
p.set_val('burn1.t_initial', value=0.0)
p.set_val('burn1.t_duration', value=2.25)
p.set_val('burn1.states:r', value=burn1.interpolate(ys=[1, 1.5], nodes='state_input'))
p.set_val('burn1.states:theta', value=burn1.interpolate(ys=[0, 1.7], nodes='state_input'))
p.set_val('burn1.states:vr', value=burn1.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('burn1.states:vt', value=burn1.interpolate(ys=[1, 1], nodes='state_input'))
p.set_val('burn1.states:accel', value=burn1.interpolate(ys=[0.1, 0], nodes='state_input'))
p.set_val('burn1.states:deltav', value=burn1.interpolate(ys=[0, 0.1], nodes='state_input'))
p.set_val('burn1.controls:u1',
value=burn1.interpolate(ys=[-3.5, 13.0], nodes='control_input'))
p.set_val('burn1.design_parameters:c', value=1.5)
p.set_val('coast.t_initial', value=2.25)
p.set_val('coast.t_duration', value=3.0)
p.set_val('coast.states:r', value=coast.interpolate(ys=[1.3, 1.5], nodes='state_input'))
p.set_val('coast.states:theta',
value=coast.interpolate(ys=[2.1767, 1.7], nodes='state_input'))
p.set_val('coast.states:vr', value=coast.interpolate(ys=[0.3285, 0], nodes='state_input'))
p.set_val('coast.states:vt', value=coast.interpolate(ys=[0.97, 1], nodes='state_input'))
p.set_val('coast.states:accel', value=coast.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('coast.controls:u1', value=coast.interpolate(ys=[0, 0], nodes='control_input'))
p.set_val('coast.design_parameters:c', value=1.5)
p.set_val('burn2.t_initial', value=5.25)
p.set_val('burn2.t_duration', value=1.75)
p.set_val('burn2.states:r', value=burn2.interpolate(ys=[1, 3], nodes='state_input'))
p.set_val('burn2.states:theta', value=burn2.interpolate(ys=[0, 4.0], nodes='state_input'))
p.set_val('burn2.states:vr', value=burn2.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('burn2.states:vt',
value=burn2.interpolate(ys=[1, np.sqrt(1 / 3)], nodes='state_input'))
p.set_val('burn2.states:accel', value=burn2.interpolate(ys=[0.1, 0], nodes='state_input'))
p.set_val('burn2.states:deltav',
value=burn2.interpolate(ys=[0.1, 0.2], nodes='state_input'))
p.set_val('burn2.controls:u1', value=burn2.interpolate(ys=[1, 1], nodes='control_input'))
p.set_val('burn2.design_parameters:c', value=1.5)
p.run_model()
def test_invalid_linkage_phase(self):
p = Problem(model=Group())
traj = Trajectory()
p.model.add_subsystem('traj', subsys=traj)
# Since we're only testing features like get_values that don't rely on a converged
# solution, no driver is attached. We'll just invoke run_model.
# First Phase (burn)
burn1 = Phase(ode_class=FiniteBurnODE, transcription=GaussLobatto(num_segments=4, order=3))
traj.add_phase('burn1', burn1)
burn1.set_time_options(fix_initial=True, duration_bounds=(.5, 10))
burn1.set_state_options('r', fix_initial=True, fix_final=False)
burn1.set_state_options('theta', fix_initial=True, fix_final=False)
burn1.set_state_options('vr', fix_initial=True, fix_final=False, defect_scaler=0.1)
burn1.set_state_options('vt', fix_initial=True, fix_final=False, defect_scaler=0.1)
burn1.set_state_options('accel', fix_initial=True, fix_final=False)
burn1.set_state_options('deltav', fix_initial=True, fix_final=False)
burn1.add_control('u1', rate_continuity=True, rate2_continuity=True, units='deg')
burn1.add_design_parameter('c', opt=False, val=1.5)
# Second Phase (Coast)
coast = Phase(ode_class=FiniteBurnODE, transcription=GaussLobatto(num_segments=10, order=3))
traj.add_phase('coast', coast)
coast.set_time_options(initial_bounds=(0.5, 20), duration_bounds=(.5, 10))
coast.set_state_options('r', fix_initial=False, fix_final=False)
coast.set_state_options('theta', fix_initial=False, fix_final=False)
coast.set_state_options('vr', fix_initial=False, fix_final=False)
coast.set_state_options('vt', fix_initial=False, fix_final=False)
coast.set_state_options('accel', fix_initial=True, fix_final=True)
coast.set_state_options('deltav', fix_initial=False, fix_final=False)
coast.add_control('u1', opt=False, val=0.0, units='deg')
coast.add_design_parameter('c', opt=False, val=1.5)
# Third Phase (burn)
burn2 = Phase(ode_class=FiniteBurnODE, transcription=GaussLobatto(num_segments=3, order=3))
traj.add_phase('burn2', burn2)
burn2.set_time_options(initial_bounds=(0.5, 20), duration_bounds=(.5, 10))
burn2.set_state_options('r', fix_initial=False, fix_final=True, defect_scaler=1.0)
burn2.set_state_options('theta', fix_initial=False, fix_final=False, defect_scaler=1.0)
burn2.set_state_options('vr', fix_initial=False, fix_final=True, defect_scaler=0.1)
burn2.set_state_options('vt', fix_initial=False, fix_final=True, defect_scaler=0.1)
burn2.set_state_options('accel', fix_initial=False, fix_final=False, defect_scaler=1.0)
burn2.set_state_options('deltav', fix_initial=False, fix_final=False, defect_scaler=1.0)
burn2.add_control('u1', rate_continuity=True, rate2_continuity=True, units='deg',
ref0=0, ref=10)
burn2.add_design_parameter('c', opt=False, val=1.5)
burn2.add_objective('deltav', loc='final')
# Link Phases
traj.link_phases(phases=['burn1', 'coast', 'burn2'],
vars=['time', 'r', 'theta', 'vr', 'vt', 'deltav'])
traj.link_phases(phases=['burn1', 'foo'], vars=['u1', 'u1'])
# Finish Problem Setup
p.model.linear_solver = DirectSolver()
p.model.add_recorder(SqliteRecorder('test_trajectory_rec.db'))
with self.assertRaises(ValueError) as e:
p.setup(check=True)
self.assertEqual(str(e.exception), 'Invalid linkage. Phase \'foo\' does not exist in '
'trajectory \'traj\'.')
def get_problem(surface, match_number=0.84, height=7000):
# Create the problem and assign the model group
prob = Problem()
grav_constant = data_heights[height]['g']
v = match_number * data_heights[height]['speed']
re = data_heights[height]['ro'] * data_heights[height][
'speed'] * match_number / data_heights[height]['visc']
rho = data_heights[height]['ro']
speed_of_sound = data_heights[height]['speed']
indep_var_comp = IndepVarComp()
indep_var_comp.add_output('v', val=v, units='m/s') # change this too
indep_var_comp.add_output('alpha', val=5., units='deg')
indep_var_comp.add_output('Mach_number', val=match_number)
indep_var_comp.add_output('re', val=re, units='1/m') # change this too
indep_var_comp.add_output('rho', val=rho, units='kg/m**3')
indep_var_comp.add_output('CT', val=grav_constant * 17.e-6, units='1/s')
indep_var_comp.add_output('R', val=11.165e6, units='m')
indep_var_comp.add_output('W0', val=0.4 * 3e5, units='kg')
indep_var_comp.add_output('speed_of_sound',
val=speed_of_sound,
units='m/s')
indep_var_comp.add_output('load_factor', val=1.)
indep_var_comp.add_output('empty_cg', val=np.zeros((3)), units='m')
prob.model.add_subsystem('prob_vars', indep_var_comp, promotes=['*'])
aerostruct_group = AerostructGeometry(surface=surface)
name = 'wing'
# Add tmp_group to the problem with the name of the surface.
prob.model.add_subsystem(name, aerostruct_group)
point_name = 'AS_point_0'
# Create the aero point group and add it to the model
AS_point = AerostructPoint(surfaces=[surface])
prob.model.add_subsystem(point_name,
AS_point,
promotes_inputs=[
'v', 'alpha', 'Mach_number', 're', 'rho',
'CT', 'R', 'W0', 'speed_of_sound', 'empty_cg',
'load_factor'
])
com_name = point_name + '.' + name + '_perf'
prob.model.connect(
name + '.local_stiff_transformed',
point_name + '.coupled.' + name + '.local_stiff_transformed')
prob.model.connect(name + '.nodes',
point_name + '.coupled.' + name + '.nodes')
# Connect aerodyamic mesh to coupled group mesh
prob.model.connect(name + '.mesh',
point_name + '.coupled.' + name + '.mesh')
# Connect performance calculation variables
prob.model.connect(name + '.radius', com_name + '.radius')
prob.model.connect(name + '.thickness', com_name + '.thickness')
prob.model.connect(name + '.nodes', com_name + '.nodes')
prob.model.connect(
name + '.cg_location',
point_name + '.' + 'total_perf.' + name + '_cg_location')
prob.model.connect(
name + '.structural_mass',
point_name + '.' + 'total_perf.' + name + '_structural_mass')
prob.model.connect(name + '.t_over_c', com_name + '.t_over_c')
prob.driver = ScipyOptimizeDriver()
prob.driver.options['tol'] = 1e-9
recorder = SqliteRecorder("aerostruct.db")
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_derivatives'] = True
prob.driver.recording_options['includes'] = ['*']
# Setup problem and add design variables, constraint, and objective
# prob.model.add_design_var('wing.twist_cp', lower=-10., upper=15.)
# prob.model.add_design_var('wing.thickness_cp', lower=0.01, upper=0.5, scaler=1e2)
prob.model.add_constraint('AS_point_0.wing_perf.failure', upper=0.)
prob.model.add_constraint('AS_point_0.wing_perf.thickness_intersects',
upper=0.)
# Add design variables, constraisnt, and objective on the problem
prob.model.add_design_var('alpha', lower=-10., upper=10.)
prob.model.add_constraint('AS_point_0.L_equals_W', equals=0.)
prob.model.add_objective('AS_point_0.fuelburn', scaler=1e-5)
prob.setup(check=True)
return prob
from betz_limit import Betz_Limit
if __name__ == "__main__":
prob = Problem()
prob.root = Betz_Limit()
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1.0e-8
prob.driver.add_desvar('a', lower=0.0, upper=1.0)
prob.driver.add_desvar('Area', lower=0.0, upper=1.0)
prob.driver.add_desvar('rho', lower=0.0, upper=1.0)
prob.driver.add_desvar('Vu', lower=0.0, upper=1.0)
# Scaler -1.0 so that we maximize.
prob.driver.add_objective('aDisc.Cp', scaler=-1.0)
recorder = SqliteRecorder('betz_limit.sql')
#recorder.options['record_params'] = True
recorder.options['record_resids'] = False
prob.driver.add_recorder(recorder)
prob.setup()
prob.run()
def setup_prob(self):
"""
Short method to select the optimizer. Uses pyOptSparse if available,
or Scipy's SLSQP otherwise.
"""
try: # Use pyOptSparse optimizer if installed
from openmdao.api import pyOptSparseDriver
self.prob.driver = pyOptSparseDriver()
if self.prob_dict['optimizer'] == 'SNOPT':
self.prob.driver.options['optimizer'] = "SNOPT"
self.prob.driver.opt_settings = {'Major optimality tolerance': 1.0e-8,
'Major feasibility tolerance': 1.0e-8,
'Major iterations limit':400,
'Minor iterations limit':2000,
'Iterations limit':1000
}
elif self.prob_dict['optimizer'] == 'ALPSO':
self.prob.driver.options['optimizer'] = 'ALPSO'
self.prob.driver.opt_settings = {'SwarmSize': 40,
'maxOuterIter': 200,
'maxInnerIter': 6,
'rtol': 1e-5,
'atol': 1e-5,
'dtol': 1e-5,
'printOuterIters': 1
}
elif self.prob_dict['optimizer'] == 'NOMAD':
self.prob.driver.options['optimizer'] = 'NOMAD'
self.prob.driver.opt_settings = {'maxiter':1000,
'minmeshsize':1e-12,
'minpollsize':1e-12,
'displaydegree':0,
'printfile':1
}
elif self.prob_dict['optimizer'] == 'SLSQP':
self.prob.driver.options['optimizer'] = 'SLSQP'
self.prob.driver.opt_settings = {'ACC' : 1e-10
}
except: # Use Scipy SLSQP optimizer if pyOptSparse not installed
self.prob.driver = ScipyOptimizer()
self.prob.driver.options['optimizer'] = 'SLSQP'
self.prob.driver.options['disp'] = True
self.prob.driver.options['tol'] = 1.0e-10
# Actually call the OpenMDAO functions to add the design variables,
# constraints, and objective.
for desvar_name, desvar_data in iteritems(self.desvars):
self.prob.driver.add_desvar(desvar_name, **desvar_data)
for con_name, con_data in iteritems(self.constraints):
self.prob.driver.add_constraint(con_name, **con_data)
for obj_name, obj_data in iteritems(self.objective):
self.prob.driver.add_objective(obj_name, **obj_data)
# Use finite differences over the entire model if user selected it
if self.prob_dict['force_fd']:
self.prob.root.deriv_options['type'] = 'fd'
# Record optimization history to a database.
# Data saved here can be examined using `plot_all.py` or `OptView.py`
if self.prob_dict['record_db']:
recorder = SqliteRecorder(self.prob_dict['prob_name']+".db")
recorder.options['record_params'] = True
recorder.options['record_derivs'] = True
self.prob.driver.add_recorder(recorder)
# Profile (time) the problem
if self.prob_dict['profile']:
profile.setup(self.prob)
profile.start()
# Set up the problem
self.prob.setup()
# Use warm start from previous db file if desired.
# Note that we only have access to the unknowns, not the gradient history.
if self.prob_dict['previous_case_db'] is not None:
# Open the previous case and start from the last iteration.
# Change the -1 value in get_case() if you want to select a different iteration.
cr = CaseReader(self.prob_dict['previous_case_db'])
case = cr.get_case(-1)
# Loop through the unknowns and set them for this problem.
for param_name, param_data in iteritems(case.unknowns):
self.prob[param_name] = param_data
def test(self):
from openaerostruct.geometry.utils import generate_mesh, write_FFD_file
from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
from openmdao.api import IndepVarComp, Problem, Group, SqliteRecorder
from pygeo import DVGeometry
# Create a dictionary to store options about the surface
mesh_dict = {'num_y' : 5,
'num_x' : 2,
'wing_type' : 'CRM',
'symmetry' : True,
'num_twist_cp' : 5}
mesh, twist_cp = generate_mesh(mesh_dict)
surf_dict = {
# Wing definition
'name' : 'wing', # name of the surface
'symmetry' : True, # if true, model one half of wing
# reflected across the plane y = 0
'S_ref_type' : 'wetted', # how we compute the wing area,
# can be 'wetted' or 'projected'
'fem_model_type' : 'tube',
'thickness_cp' : np.array([.1, .2, .3]),
'mesh' : mesh,
'geom_manipulator' : 'FFD',
'mx' : 2,
'my' : 3,
# Aerodynamic performance of the lifting surface at
# an angle of attack of 0 (alpha=0).
# These CL0 and CD0 values are added to the CL and CD
# obtained from aerodynamic analysis of the surface to get
# the total CL and CD.
# These CL0 and CD0 values do not vary wrt alpha.
'CL0' : 0.0, # CL of the surface at alpha=0
'CD0' : 0.015, # CD of the surface at alpha=0
# Airfoil properties for viscous drag calculation
'k_lam' : 0.05, # percentage of chord with laminar
# flow, used for viscous drag
't_over_c_cp' : np.array([0.15]), # thickness over chord ratio (NACA0015)
'c_max_t' : .303, # chordwise location of maximum (NACA0015)
# thickness
'with_viscous' : True,
'with_wave' : False, # if true, compute wave drag
# Structural values are based on aluminum 7075
'E' : 70.e9, # [Pa] Young's modulus of the spar
'G' : 30.e9, # [Pa] shear modulus of the spar
'yield' : 500.e6 / 2.5, # [Pa] yield stress divided by 2.5 for limiting case
'mrho' : 3.e3, # [kg/m^3] material density
'fem_origin' : 0.35, # normalized chordwise location of the spar
'wing_weight_ratio' : 2.,
'struct_weight_relief' : False, # True to add the weight of the structure to the loads on the structure
'distributed_fuel_weight' : False,
# Constraints
'exact_failure_constraint' : False, # if false, use KS function
}
surfaces = [surf_dict]
# Create the problem and assign the model group
prob = Problem()
# Add problem information as an independent variables component
indep_var_comp = IndepVarComp()
indep_var_comp.add_output('v', val=248.136, units='m/s')
indep_var_comp.add_output('alpha', val=5., units='deg')
indep_var_comp.add_output('Mach_number', val=0.84)
indep_var_comp.add_output('re', val=1.e6, units='1/m')
indep_var_comp.add_output('rho', val=0.38, units='kg/m**3')
indep_var_comp.add_output('CT', val=9.80665 * 17.e-6, units='1/s')
indep_var_comp.add_output('R', val=11.165e6, units='m')
indep_var_comp.add_output('W0', val=0.4 * 3e5, units='kg')
indep_var_comp.add_output('speed_of_sound', val=295.4, units='m/s')
indep_var_comp.add_output('load_factor', val=1.)
indep_var_comp.add_output('empty_cg', val=np.zeros((3)), units='m')
prob.model.add_subsystem('prob_vars',
indep_var_comp,
promotes=['*'])
# Loop over each surface in the surfaces list
for surface in surfaces:
# Get the surface name and create a group to contain components
# only for this surface
name = surface['name']
filename = write_FFD_file(surface, surface['mx'], surface['my'])
DVGeo = DVGeometry(filename)
aerostruct_group = AerostructGeometry(surface=surface, DVGeo=DVGeo)
# Add tmp_group to the problem with the name of the surface.
prob.model.add_subsystem(name, aerostruct_group)
# Loop through and add a certain number of aero points
for i in range(1):
point_name = 'AS_point_{}'.format(i)
# Connect the parameters within the model for each aero point
# Create the aero point group and add it to the model
AS_point = AerostructPoint(surfaces=surfaces)
prob.model.add_subsystem(point_name, AS_point)
# Connect flow properties to the analysis point
prob.model.connect('v', point_name + '.v')
prob.model.connect('alpha', point_name + '.alpha')
prob.model.connect('Mach_number', point_name + '.Mach_number')
prob.model.connect('re', point_name + '.re')
prob.model.connect('rho', point_name + '.rho')
prob.model.connect('CT', point_name + '.CT')
prob.model.connect('R', point_name + '.R')
prob.model.connect('W0', point_name + '.W0')
prob.model.connect('speed_of_sound', point_name + '.speed_of_sound')
prob.model.connect('empty_cg', point_name + '.empty_cg')
prob.model.connect('load_factor', point_name + '.load_factor')
for surface in surfaces:
prob.model.connect('load_factor', name + '.load_factor')
com_name = point_name + '.' + name + '_perf'
prob.model.connect(name + '.local_stiff_transformed', point_name + '.coupled.' + name + '.local_stiff_transformed')
prob.model.connect(name + '.nodes', point_name + '.coupled.' + name + '.nodes')
# Connect aerodyamic mesh to coupled group mesh
prob.model.connect(name + '.mesh', point_name + '.coupled.' + name + '.mesh')
# Connect performance calculation variables
prob.model.connect(name + '.radius', com_name + '.radius')
prob.model.connect(name + '.thickness', com_name + '.thickness')
prob.model.connect(name + '.nodes', com_name + '.nodes')
prob.model.connect(name + '.cg_location', point_name + '.' + 'total_perf.' + name + '_cg_location')
prob.model.connect(name + '.structural_weight', point_name + '.' + 'total_perf.' + name + '_structural_weight')
prob.model.connect(name + '.t_over_c', com_name + '.t_over_c')
# Import the Scipy Optimizer and set the driver of the problem to use
# it, which defaults to an SLSQP optimization method
from openmdao.api import ScipyOptimizeDriver
prob.driver = ScipyOptimizeDriver()
recorder = SqliteRecorder("aerostruct_ffd.db")
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_derivatives'] = True
prob.driver.recording_options['includes'] = ['*']
# Setup problem and add design variables, constraint, and objective
prob.model.add_design_var('wing.shape', lower=-3, upper=2)
prob.model.add_design_var('wing.thickness_cp', lower=0.01, upper=0.5, scaler=1e2)
prob.model.add_constraint('AS_point_0.wing_perf.failure', upper=0.)
prob.model.add_constraint('AS_point_0.wing_perf.thickness_intersects', upper=0.)
# Add design variables, constraisnt, and objective on the problem
prob.model.add_design_var('alpha', lower=-10., upper=10.)
prob.model.add_constraint('AS_point_0.L_equals_W', equals=0.)
prob.model.add_objective('AS_point_0.fuelburn', scaler=1e-5)
# iprofile.setup()
# iprofile.start()
# Set up the problem
prob.setup()
# from openmdao.api import view_model
# view_model(prob, outfile='aerostruct_ffd', show_browser=False)
# prob.run_model()
prob.run_driver()
# prob.check_partials(compact_print=True)
# print("\nWing CL:", prob['aero_point_0.wing_perf.CL'])
# print("Wing CD:", prob['aero_point_0.wing_perf.CD'])
# from helper import plot_3d_points
#
# mesh = prob['aero_point_0.wing.def_mesh']
# plot_3d_points(mesh)
#
# filename = mesh_dict['wing_type'] + '_' + str(mesh_dict['num_x']) + '_' + str(mesh_dict['num_y'])
# filename += '_' + str(surf_dict['mx']) + '_' + str(surf_dict['my']) + '.mesh'
# np.save(filename, mesh)
assert_rel_error(self, prob['AS_point_0.fuelburn'][0], 104675.0989232741, 1e-3)
def test(self):
# Create a dictionary to store options about the surface
mesh_dict = {
'num_y': 11,
'num_x': 3,
'wing_type': 'CRM',
'symmetry': False,
'num_twist_cp': 5
}
mesh, twist_cp = generate_mesh(mesh_dict)
surf_dict = {
# Wing definition
'name': 'wing', # name of the surface
'type': 'aero',
'symmetry': False, # if true, model one half of wing
# reflected across the plane y = 0
'S_ref_type': 'wetted', # how we compute the wing area,
# can be 'wetted' or 'projected'
'mesh': mesh,
'num_x': mesh.shape[0],
'num_y': mesh.shape[1],
'twist_cp': twist_cp,
# Aerodynamic performance of the lifting surface at
# an angle of attack of 0 (alpha=0).
# These CL0 and CD0 values are added to the CL and CD
# obtained from aerodynamic analysis of the surface to get
# the total CL and CD.
# These CL0 and CD0 values do not vary wrt alpha.
'CL0': 0.0, # CL of the surface at alpha=0
'CD0': 0.0, # CD of the surface at alpha=0
# Airfoil properties for viscous drag calculation
'k_lam': 0.05, # percentage of chord with laminar
# flow, used for viscous drag
't_over_c_cp':
np.array([0.15]), # thickness over chord ratio (NACA0015)
'c_max_t': .303, # chordwise location of maximum (NACA0015)
# thickness
'with_viscous': True, # if true, compute viscous drag
'with_wave': True, # if true, compute wave drag
}
surfaces = [surf_dict]
# Create the problem and the model group
prob = Problem()
indep_var_comp = IndepVarComp()
indep_var_comp.add_output('v', val=248.136, units='m/s')
indep_var_comp.add_output('alpha', val=5., units='deg')
indep_var_comp.add_output('M', val=0.84)
indep_var_comp.add_output('re', val=1.e6, units='1/m')
indep_var_comp.add_output('rho', val=0.38, units='kg/m**3')
indep_var_comp.add_output('cg', val=np.zeros((3)), units='m')
prob.model.add_subsystem('prob_vars', indep_var_comp, promotes=['*'])
# Loop over each surface in the surfaces list
for surface in surfaces:
geom_group = Geometry(surface=surface)
# Add tmp_group to the problem as the name of the surface.
# Note that is a group and performance group for each
# individual surface.
prob.model.add_subsystem(surface['name'], geom_group)
# Loop through and add a certain number of aero points
for i in range(1):
# Create the aero point group and add it to the model
aero_group = AeroPoint(surfaces=surfaces)
point_name = 'aero_point_{}'.format(i)
prob.model.add_subsystem(point_name, aero_group)
# Connect flow properties to the analysis point
prob.model.connect('v', point_name + '.v')
prob.model.connect('alpha', point_name + '.alpha')
prob.model.connect('M', point_name + '.M')
prob.model.connect('re', point_name + '.re')
prob.model.connect('rho', point_name + '.rho')
prob.model.connect('cg', point_name + '.cg')
# Connect the parameters within the model for each aero point
for surface in surfaces:
name = surface['name']
# Connect the mesh from the geometry component to the analysis point
prob.model.connect(name + '.mesh',
point_name + '.' + name + '.def_mesh')
# Perform the connections with the modified names within the
# 'aero_states' group.
prob.model.connect(
name + '.mesh',
point_name + '.aero_states.' + name + '_def_mesh')
prob.model.connect(
name + '.t_over_c',
point_name + '.' + name + '_perf.' + 't_over_c')
from openmdao.api import ScipyOptimizeDriver
prob.driver = ScipyOptimizeDriver()
prob.driver.options['tol'] = 1e-9
recorder = SqliteRecorder("aero_opt_wavedrag.db")
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_derivatives'] = True
# Setup problem and add design variables, constraint, and objective
prob.model.add_design_var('wing.twist_cp', lower=-10., upper=15.)
prob.model.add_constraint(point_name + '.wing_perf.CL', equals=0.5)
prob.model.add_objective(point_name + '.wing_perf.CD', scaler=1e4)
# Set up the problem
prob.setup()
prob.run_driver()
assert_rel_error(self, prob['aero_point_0.wing_perf.CL'][0], 0.5, 1e-6)
assert_rel_error(self, prob['aero_point_0.wing_perf.CD'][0],
0.02257921, 1e-6)
assert_rel_error(self, prob['aero_point_0.CM'][1], -0.179451279, 1e-6)
])
#Connect Indep Variables
root.connect('Mach_number.Mach', 'aerodynamics_h.Mach')
root.connect('b_baseline', 'aerodynamics_h.b')
root.connect('wing_chord.c', 'aerodynamics_h.c')
root.connect('Poissons_ratio.nu', 'structures_h.nu')
root.connect('Youngs_modulus.E', 'structures_h.E')
root.connect('material_density.rho_s', 'structures_h.rho_s')
#Multifidelity explicit connections
root.connect('structures.u', 'mult_filter_h.ul')
root.connect('structures_h.u', 'mult_filter_l.ul')
#Recorder Lo-Fi
recorder_l = SqliteRecorder('mda_l.sqlite3')
recorder_l.options['record_metadata'] = False
#Recorder Hi-Fi
recorder_h = SqliteRecorder('mda_h.sqlite3')
recorder_h.options['record_metadata'] = False
top.root.mda_group_l.nl_solver.add_recorder(recorder_l)
top.root.mda_group_h.nl_solver.add_recorder(recorder_h)
#Constraint components
#Lift coefficient constraints (two constraints with same value to treat equality constraint as two inequality constraints)
root.add(
'con_lift_cruise_upper',
ExecComp(
'con_l_u = CL - n*(W_airframe+2*1.25*mass)*9.81/(0.5*rho_a*V**2*Sw)'
),
promotes=['*'])
# upper=secondTurbineXInitialPosition)
# prob.driver.add_desvar('turbineY2', scaler=1E1, lower=secondTurbineYInitialPosition,
# upper=secondTurbineYInitialPosition)
# prob.driver.add_desvar('turbineX3', scaler=1E1, lower=secondTurbineXInitialPosition,
# upper=secondTurbineXInitialPosition)
# prob.driver.add_desvar('turbineY3', scaler=1E1, lower=np.ones(nTurbines) * -3. * boundary_radius,
# upper=np.ones(nTurbines) * 3. * boundary_radius)
prob.root.ln_solver.options['single_voi_relevance_reduction'] = True
prob.root.ln_solver.options['mode'] = 'rev'
# Import OpenMDAO's recorder to track the downwind turbine's movements during the optimization.
# Good to use for small cases like this debugger, but not for large scale problems.
from openmdao.api import SqliteRecorder
import sqlitedict
recorder = SqliteRecorder('AEP')
recorder.options['includes'] = ['turbineX', 'turbineY']
prob.driver.add_recorder(recorder)
# Begin setting up the problem and running it.
print("almost time for setup")
tic = time.time()
print("entering setup at time = ", tic)
prob.setup(check=True)
toc = time.time()
mpi_print(prob, "setup complete at time = ", toc)
# print the results
mpi_print(prob, ('Problem setup took %.03f sec.' % (toc - tic)))
# assign initial values to design variables
top.root.connect('indep3.cruiseSpeed', 'subprob.indep3.cruiseSpeed')
top.root.connect('indep4.batteryMass', 'subprob.indep4.batteryMass')
top.root.connect('indep5.motorMass', 'subprob.indep5.motorMass')
top.root.connect('indep6.mtom', 'subprob.indep6.mtom')
# TopProblem: set up the parameter study
# for a parameter study, the following drivers can be used:
# UniformDriver, FullFactorialDriver, LatinHypercubeDriver, OptimizedLatinHypercubeDriver
# in this case, we will use FullFactorialDriver
top.driver = FullFactorialDriver(num_levels=20)
# TopProblem: add top.driver's design variables
top.driver.add_desvar('indep1.range', lower=10000.0, upper=200000.0)
# Data collection
recorder = SqliteRecorder('subprob')
recorder.options['record_params'] = True
recorder.options['record_metadata'] = True
top.driver.add_recorder(recorder)
# Setup
top.setup(check=False)
# Run
top.run()
# Cleanup
top.cleanup()
# Data retrieval & display
# Old way - good for debugging IndepVars
from openmdao.api import Problem, SqliteRecorder
from openmdao.test_suite.components.sellar import SellarProblem, SellarDerivativesGrouped
from openmdao.drivers.pyoptsparse_driver import pyOptSparseDriver
recorder = SqliteRecorder("sellar_grouped.db")
prob = SellarProblem(SellarDerivativesGrouped)
driver = prob.driver = pyOptSparseDriver(optimizer='SLSQP')
prob.model.add_recorder(recorder, True)
driver.add_recorder(recorder)
prob.setup()
prob.run_driver()
prob.cleanup()
help="run doe in parallel")
(options, args) = parser.parse_args()
pb = Problem(SsbjMda())
sa_method_name = 'Morris'
sa_doe_options = {'n_trajs': 10, 'n_levels': 4}
if options.sobol:
sa_method_name = 'Sobol'
sa_doe_options = {'n_samples': 500, 'calc_second_order': False}
pb.driver = SalibDOEDriver(sa_method_name=sa_method_name,
sa_doe_options=sa_doe_options)
pb.driver.options['run_parallel'] = options.parallel
case_recorder_filename = 'ssbj_mda_screening.sqlite'
recorder = SqliteRecorder(case_recorder_filename)
pb.driver.add_recorder(recorder)
pb.model.nonlinear_solver.options['err_on_non_converge'] = True
pb.model.add_design_var('x_aer', lower=0.75, upper=1.25)
pb.model.add_design_var('x_pro', lower=0.18, upper=1.81)
pb.model.add_design_var('x_str', lower=[0.4, 0.75], upper=[1.6, 1.25])
pb.model.add_design_var('z',
lower=[0.2, 0.666, 0.875, 0.45, 0.72, 0.5],
upper=[1.8, 1.333, 1.125, 1.45, 1.27, 1.5])
pb.model.add_objective('R', scaler=-1.)
pb.model.add_constraint('con1_esf', upper=0.)
pb.model.add_constraint('con2_esf', upper=0.)
prob.driver = ScipyOptimizeDriver()
prob.driver.options['dynamic_simul_derivs'] = True
#prob.driver.options['tol'] = 1e-13
if write_logs:
filename_to_save = 'case_' + str(spec_energy) + '_' + str(
design_range) + '.sql'
if os.path.isfile(filename_to_save):
if design_range != 300:
last_successful_opt = filename_to_save
else:
last_successful_opt = 'case_' + str(
spec_energy + 50) + '_' + str(700) + '.sql'
print('Skipping ' + filename_to_save)
continue
recorder = SqliteRecorder(filename_to_save)
prob.driver.add_recorder(recorder)
prob.driver.recording_options['includes'] = []
prob.driver.recording_options['record_objectives'] = True
prob.driver.recording_options['record_constraints'] = True
prob.driver.recording_options['record_desvars'] = True
prob.setup(check=False)
# set some (required) mission parameters. Each pahse needs a vertical and air-speed
# the entire mission needs a cruise altitude and range
prob.set_val('climb.fltcond|vs',
np.ones((num_nodes, )) * 1500,
units='ft/min')
prob.set_val('climb.fltcond|Ueas',
np.ones((num_nodes, )) * 124,
units='kn')
def setUp(self):
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "sqlite_test")
self.recorder = SqliteRecorder(self.filename)
self.eps = 1e-5
try: # Use SNOPT optimizer if installed
from openmdao.api import pyOptSparseDriver
prob.driver = pyOptSparseDriver()
prob.driver.options['optimizer'] = "SNOPT"
prob.driver.opt_settings = {
'Major optimality tolerance': 1.0e-7,
'Major feasibility tolerance': 1.0e-7
}
except: # Use SLSQP optimizer if SNOPT not installed
prob.driver = ScipyOptimizer()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['disp'] = True
prob.driver.options['tol'] = 1.0e-3
prob.driver.options['maxiter'] = 40
prob.driver.add_recorder(SqliteRecorder('aerostruct.db'))
###############################################################
# Add design vars
###############################################################
prob.driver.add_desvar('twist_cp', lower=-10., upper=10., scaler=1e0)
prob.driver.add_desvar('alpha', lower=-10., upper=10., scaler=1e0)
prob.driver.add_desvar('thickness_cp', lower=0.003, upper=0.25, scaler=1000)
###############################################################
# Add constraints, and objectives
###############################################################
prob.driver.add_objective('fuelburn')
prob.driver.add_constraint('failure', upper=0.0)
prob.driver.add_constraint('eq_con', equals=0.0)
## Use these settings if you do not have pyOptSparse or SNOPT
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
prob.driver.options['tol'] = 1e-8
# # The following are the optimizer settings used for the EngOpt conference paper
# # Uncomment them if you can use SNOPT
# from openmdao.api import pyOptSparseDriver
# prob.driver = pyOptSparseDriver()
# prob.driver.options['optimizer'] = "SNOPT"
# prob.driver.opt_settings['Major optimality tolerance'] = 5e-6
# prob.driver.opt_settings['Major feasibility tolerance'] = 1e-8
# prob.driver.opt_settings['Major iterations limit'] = 200
recorder = SqliteRecorder("aerostruct.db")
prob.driver.add_recorder(recorder)
# We could also just use prob.driver.recording_options['includes']=['*'] here, but for large meshes the database file becomes extremely large. So we just select the variables we need.
prob.driver.recording_options['includes'] = [
'alpha',
'rho',
'v',
'cg',
'AS_point_1.cg',
'AS_point_0.cg',
'AS_point_0.coupled.wing_loads.loads',
'AS_point_1.coupled.wing_loads.loads',
'AS_point_0.coupled.wing.normals',
'AS_point_1.coupled.wing.normals',
'AS_point_0.coupled.wing.widths',
# Add driver
OptimizationProfilerRepeat.driver = FullFactorialDriver(
num_levels=10) # generate 10 profiler samples
OptimizationProfilerRepeat.driver.add_desvar('p1.n', lower=0.0, upper=10.0)
OptimizationProfilerRepeat.driver.add_objective(
'OptimizationProfiler.MeasureTime.time')
OptimizationProfilerRepeat.driver.add_objective(
'OptimizationProfiler.OptimizationProblem.Paraboloid.f_xy')
OptimizationProfilerRepeat.driver.add_objective(
'OptimizationProfiler.OptimizationProblem.output1.x_f')
OptimizationProfilerRepeat.driver.add_objective(
'OptimizationProfiler.OptimizationProblem.output2.y_f')
# Data collection
recorder = SqliteRecorder('record_results')
recorder.options['record_params'] = True
recorder.options['record_metadata'] = True
OptimizationProfilerRepeat.driver.add_recorder(recorder)
# Setup
OptimizationProfilerRepeat.setup(check=False)
# Run
OptimizationProfilerRepeat.run()
# Cleanup
OptimizationProfilerRepeat.cleanup()
# Data retrieval & display
# Old way - good for debugging IndepVars
def test_two_burn_orbit_raise_for_docs(self):
import numpy as np
import matplotlib.pyplot as plt
from openmdao.api import Problem, pyOptSparseDriver, DirectSolver, SqliteRecorder
from openmdao.utils.assert_utils import assert_rel_error
from openmdao.utils.general_utils import set_pyoptsparse_opt
from dymos import Phase, Trajectory
from dymos.examples.finite_burn_orbit_raise.finite_burn_eom import FiniteBurnODE
traj = Trajectory()
p = Problem(model=traj)
p.driver = pyOptSparseDriver()
_, optimizer = set_pyoptsparse_opt('SNOPT', fallback=False)
p.driver.options['optimizer'] = 'SNOPT'
p.driver.options['dynamic_simul_derivs'] = True
traj.add_design_parameter('c', opt=False, val=1.5)
# First Phase (burn)
burn1 = Phase('gauss-lobatto',
ode_class=FiniteBurnODE,
num_segments=10,
transcription_order=3,
compressed=True)
burn1 = traj.add_phase('burn1', burn1)
burn1.set_time_options(fix_initial=True, duration_bounds=(.5, 10))
burn1.set_state_options('r',
fix_initial=True,
fix_final=False,
defect_scaler=100.0)
burn1.set_state_options('theta',
fix_initial=True,
fix_final=False,
defect_scaler=100.0)
burn1.set_state_options('vr',
fix_initial=True,
fix_final=False,
defect_scaler=100.0)
burn1.set_state_options('vt',
fix_initial=True,
fix_final=False,
defect_scaler=100.0)
burn1.set_state_options('accel', fix_initial=True, fix_final=False)
burn1.set_state_options('deltav', fix_initial=True, fix_final=False)
burn1.add_control('u1',
rate_continuity=True,
rate2_continuity=True,
units='deg',
scaler=0.01,
rate_continuity_scaler=0.001,
rate2_continuity_scaler=0.001,
lower=-30,
upper=30)
# Second Phase (Coast)
coast = Phase('gauss-lobatto',
ode_class=FiniteBurnODE,
num_segments=10,
transcription_order=3,
compressed=True)
traj.add_phase('coast', coast)
coast.set_time_options(initial_bounds=(0.5, 20),
duration_bounds=(.5, 10),
duration_ref=10)
coast.set_state_options('r',
fix_initial=False,
fix_final=False,
defect_scaler=100.0)
coast.set_state_options('theta',
fix_initial=False,
fix_final=False,
defect_scaler=100.0)
coast.set_state_options('vr',
fix_initial=False,
fix_final=False,
defect_scaler=100.0)
coast.set_state_options('vt',
fix_initial=False,
fix_final=False,
defect_scaler=100.0)
coast.set_state_options('accel', fix_initial=True, fix_final=True)
coast.set_state_options('deltav', fix_initial=False, fix_final=False)
coast.add_control('u1', opt=False, val=0.0, units='deg')
# Third Phase (burn)
burn2 = Phase('gauss-lobatto',
ode_class=FiniteBurnODE,
num_segments=10,
transcription_order=3,
compressed=True)
traj.add_phase('burn2', burn2)
burn2.set_time_options(initial_bounds=(0.5, 20),
duration_bounds=(.5, 10),
initial_ref=10)
burn2.set_state_options('r',
fix_initial=False,
fix_final=True,
defect_scaler=100.0)
burn2.set_state_options('theta',
fix_initial=False,
fix_final=False,
defect_scaler=100.0)
burn2.set_state_options('vr',
fix_initial=False,
fix_final=True,
defect_scaler=100.0)
burn2.set_state_options('vt',
fix_initial=False,
fix_final=True,
defect_scaler=100.0)
burn2.set_state_options('accel',
fix_initial=False,
fix_final=False,
defect_scaler=1.0)
burn2.set_state_options('deltav',
fix_initial=False,
fix_final=False,
defect_scaler=1.0)
burn2.add_control('u1',
rate_continuity=True,
rate2_continuity=True,
units='deg',
scaler=0.01,
rate_continuity_scaler=0.001,
rate2_continuity_scaler=0.001,
lower=-30,
upper=30)
burn2.add_objective('deltav', loc='final', scaler=1.0)
# Link Phases
traj.link_phases(phases=['burn1', 'coast', 'burn2'],
vars=['time', 'r', 'theta', 'vr', 'vt', 'deltav'])
traj.link_phases(phases=['burn1', 'burn2'], vars=['accel'])
# Finish Problem Setup
p.model.options['assembled_jac_type'] = 'csc'
p.model.linear_solver = DirectSolver(assemble_jac=True)
p.driver.add_recorder(
SqliteRecorder('two_burn_orbit_raise_example_for_docs.db'))
p.setup(check=True)
# Set Initial Guesses
p.set_val('design_parameters:c', value=1.5)
p.set_val('burn1.t_initial', value=0.0)
p.set_val('burn1.t_duration', value=2.25)
p.set_val('burn1.states:r',
value=burn1.interpolate(ys=[1, 1.5], nodes='state_input'))
p.set_val('burn1.states:theta',
value=burn1.interpolate(ys=[0, 1.7], nodes='state_input'))
p.set_val('burn1.states:vr',
value=burn1.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('burn1.states:vt',
value=burn1.interpolate(ys=[1, 1], nodes='state_input'))
p.set_val('burn1.states:accel',
value=burn1.interpolate(ys=[0.1, 0], nodes='state_input'))
p.set_val(
'burn1.states:deltav',
value=burn1.interpolate(ys=[0, 0.1], nodes='state_input'),
)
p.set_val('burn1.controls:u1',
value=burn1.interpolate(ys=[-3.5, 13.0],
nodes='control_input'))
p.set_val('coast.t_initial', value=2.25)
p.set_val('coast.t_duration', value=3.0)
p.set_val('coast.states:r',
value=coast.interpolate(ys=[1.3, 1.5], nodes='state_input'))
p.set_val('coast.states:theta',
value=coast.interpolate(ys=[2.1767, 1.7],
nodes='state_input'))
p.set_val('coast.states:vr',
value=coast.interpolate(ys=[0.3285, 0], nodes='state_input'))
p.set_val('coast.states:vt',
value=coast.interpolate(ys=[0.97, 1], nodes='state_input'))
p.set_val('coast.states:accel',
value=coast.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('coast.controls:u1',
value=coast.interpolate(ys=[0, 0], nodes='control_input'))
p.set_val('burn2.t_initial', value=5.25)
p.set_val('burn2.t_duration', value=1.75)
p.set_val('burn2.states:r',
value=burn2.interpolate(ys=[1, 3], nodes='state_input'))
p.set_val('burn2.states:theta',
value=burn2.interpolate(ys=[0, 4.0], nodes='state_input'))
p.set_val('burn2.states:vr',
value=burn2.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('burn2.states:vt',
value=burn2.interpolate(ys=[1, np.sqrt(1 / 3)],
nodes='state_input'))
p.set_val('burn2.states:accel',
value=burn2.interpolate(ys=[0.1, 0], nodes='state_input'))
p.set_val('burn2.states:deltav',
value=burn2.interpolate(ys=[0.1, 0.2], nodes='state_input'))
p.set_val('burn2.controls:u1',
value=burn2.interpolate(ys=[1, 1], nodes='control_input'))
p.run_driver()
assert_rel_error(self,
traj.get_values('deltav', flat=True)[-1],
0.3995,
tolerance=2.0E-3)
# Plot results
exp_out = traj.simulate(times=50, num_procs=3)
fig = plt.figure(figsize=(8, 4))
fig.suptitle('Two Burn Orbit Raise Solution')
ax_u1 = plt.subplot2grid((2, 2), (0, 0))
ax_deltav = plt.subplot2grid((2, 2), (1, 0))
ax_xy = plt.subplot2grid((2, 2), (0, 1), rowspan=2)
span = np.linspace(0, 2 * np.pi, 100)
ax_xy.plot(np.cos(span), np.sin(span), 'k--', lw=1)
ax_xy.plot(3 * np.cos(span), 3 * np.sin(span), 'k--', lw=1)
ax_xy.set_xlim(-4.5, 4.5)
ax_xy.set_ylim(-4.5, 4.5)
ax_xy.set_xlabel('x ($R_e$)')
ax_xy.set_ylabel('y ($R_e$)')
ax_u1.set_xlabel('time ($TU$)')
ax_u1.set_ylabel('$u_1$ ($deg$)')
ax_u1.grid(True)
ax_deltav.set_xlabel('time ($TU$)')
ax_deltav.set_ylabel('${\Delta}v$ ($DU/TU$)')
ax_deltav.grid(True)
t_sol = traj.get_values('time')
x_sol = traj.get_values('pos_x')
y_sol = traj.get_values('pos_y')
dv_sol = traj.get_values('deltav')
u1_sol = traj.get_values('u1', units='deg')
t_exp = exp_out.get_values('time')
x_exp = exp_out.get_values('pos_x')
y_exp = exp_out.get_values('pos_y')
dv_exp = exp_out.get_values('deltav')
u1_exp = exp_out.get_values('u1', units='deg')
for phase_name in ['burn1', 'coast', 'burn2']:
ax_u1.plot(t_sol[phase_name], u1_sol[phase_name], 'ro', ms=3)
ax_u1.plot(t_exp[phase_name], u1_exp[phase_name], 'b-')
ax_deltav.plot(t_sol[phase_name], dv_sol[phase_name], 'ro', ms=3)
ax_deltav.plot(t_exp[phase_name], dv_exp[phase_name], 'b-')
ax_xy.plot(x_sol[phase_name],
y_sol[phase_name],
'ro',
ms=3,
label='implicit' if phase_name == 'burn1' else None)
ax_xy.plot(x_exp[phase_name],
y_exp[phase_name],
'b-',
label='explicit' if phase_name == 'burn1' else None)
plt.show()
top.driver.add_constraint('delta_omega_l_' + str(i + 1),
lower=0.,
scaler=1 / np.sqrt(eigval_ref[i]))
for i in range(tn):
top.driver.add_constraint('t_l_' + str(i + 1),
lower=0.,
scaler=1 / t_0[i])
for i in range(mn):
top.driver.add_constraint('m_l_' + str(i + 1),
lower=0.,
scaler=1 / m_0[i])
#Optimization Recorder
recorder = SqliteRecorder('modal_optim_COBYLA_scale1to9_case')
recorder.options['record_params'] = True
recorder.options['record_metadata'] = True
top.driver.add_recorder(recorder)
top.setup()
view_model(top, show_browser=False)
#Setting initial values for design variables
top['t'] = t_0
top['m'] = m_0
# top['t'] = np.array([50.,11.,10.,10.,10.,10.])
# top['m'] = np.array([0.5,0.2,0.2])
top.run()
top.root = SellarDerivatives()
# top.driver = ScipyOptimizer()
# top.driver.options['optimizer'] = 'SLSQP'
# top.driver.options['tol'] = 1.0e-8
top.driver = pyOptSparseDriver()
top.driver.options['optimizer'] = 'SNOPT'
top.driver.add_desvar('z', lower=np.array([-10.0, 0.0]),
upper=np.array([10.0, 10.0]))
top.driver.add_desvar('x', lower=0.0, upper=10.0)
top.driver.add_objective('obj')
top.driver.add_constraint('con1', upper=0.0)
top.driver.add_constraint('con2', upper=0.0)
rec = SqliteRecorder('sellar_snopt.db')
top.driver.add_recorder(rec)
rec.options['record_derivs'] = True
top.setup()
top.run()
print("\n")
print( "Minimum found at (%f, %f, %f)" % (top['z'][0],
top['z'][1],
top['x']))
print("Coupling vars: %f, %f" % (top['y1'], top['y2']))
print("Minimum objective: ", top['obj'])
def two_burn_orbit_raise_problem(transcription='gauss-lobatto',
optimizer='SLSQP',
r_target=3.0,
transcription_order=3,
compressed=False,
show_output=True,
connected=False):
p = Problem(model=Group())
p.driver = pyOptSparseDriver()
p.driver.options['optimizer'] = optimizer
if optimizer == 'SNOPT':
p.driver.options['dynamic_simul_derivs'] = True
p.driver.opt_settings['Major iterations limit'] = 100
p.driver.opt_settings['Major feasibility tolerance'] = 1.0E-6
p.driver.opt_settings['Major optimality tolerance'] = 1.0E-6
if show_output:
p.driver.opt_settings['iSumm'] = 6
else:
p.driver.options['dynamic_simul_derivs'] = True
traj = make_traj(transcription=transcription,
transcription_order=transcription_order,
compressed=compressed,
connected=connected)
p.model.add_subsystem('traj', subsys=traj)
# Finish Problem Setup
# Needed to move the direct solver down into the phases for use with MPI.
# - After moving down, used fewer iterations (about 30 less)
p.driver.add_recorder(SqliteRecorder('two_burn_orbit_raise_example.db'))
p.setup(check=True)
# Set Initial Guesses
p.set_val('traj.design_parameters:c', value=1.5, units='DU/TU')
burn1 = p.model.traj.phases.burn1
burn2 = p.model.traj.phases.burn2
coast = p.model.traj.phases.coast
if burn1 in p.model.traj.phases._subsystems_myproc:
p.set_val('traj.burn1.t_initial', value=0.0)
p.set_val('traj.burn1.t_duration', value=2.25)
p.set_val('traj.burn1.states:r',
value=burn1.interpolate(ys=[1, 1.5], nodes='state_input'))
p.set_val('traj.burn1.states:theta',
value=burn1.interpolate(ys=[0, 1.7], nodes='state_input'))
p.set_val('traj.burn1.states:vr',
value=burn1.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('traj.burn1.states:vt',
value=burn1.interpolate(ys=[1, 1], nodes='state_input'))
p.set_val('traj.burn1.states:accel',
value=burn1.interpolate(ys=[0.1, 0], nodes='state_input'))
p.set_val('traj.burn1.states:deltav',
value=burn1.interpolate(ys=[0, 0.1], nodes='state_input'))
p.set_val('traj.burn1.controls:u1',
value=burn1.interpolate(ys=[-3.5, 13.0],
nodes='control_input'))
if coast in p.model.traj.phases._subsystems_myproc:
p.set_val('traj.coast.t_initial', value=2.25)
p.set_val('traj.coast.t_duration', value=3.0)
p.set_val('traj.coast.states:r',
value=coast.interpolate(ys=[1.3, 1.5], nodes='state_input'))
p.set_val('traj.coast.states:theta',
value=coast.interpolate(ys=[2.1767, 1.7],
nodes='state_input'))
p.set_val('traj.coast.states:vr',
value=coast.interpolate(ys=[0.3285, 0], nodes='state_input'))
p.set_val('traj.coast.states:vt',
value=coast.interpolate(ys=[0.97, 1], nodes='state_input'))
p.set_val('traj.coast.states:accel',
value=coast.interpolate(ys=[0, 0], nodes='state_input'))
if burn2 in p.model.traj.phases._subsystems_myproc:
if connected:
p.set_val('traj.burn2.t_initial', value=7.0)
p.set_val('traj.burn2.t_duration', value=-1.75)
p.set_val('traj.burn2.states:r',
value=burn2.interpolate(ys=[r_target, 1],
nodes='state_input'))
p.set_val('traj.burn2.states:theta',
value=burn2.interpolate(ys=[4.0, 0.0],
nodes='state_input'))
p.set_val('traj.burn2.states:vr',
value=burn2.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('traj.burn2.states:vt',
value=burn2.interpolate(ys=[np.sqrt(1 / r_target), 1],
nodes='state_input'))
p.set_val('traj.burn2.states:deltav',
value=burn2.interpolate(ys=[0.2, 0.1],
nodes='state_input'))
p.set_val('traj.burn2.states:accel',
value=burn2.interpolate(ys=[0., 0.1],
nodes='state_input'))
else:
p.set_val('traj.burn2.t_initial', value=5.25)
p.set_val('traj.burn2.t_duration', value=1.75)
p.set_val('traj.burn2.states:r',
value=burn2.interpolate(ys=[1, r_target],
nodes='state_input'))
p.set_val('traj.burn2.states:theta',
value=burn2.interpolate(ys=[0, 4.0],
nodes='state_input'))
p.set_val('traj.burn2.states:vr',
value=burn2.interpolate(ys=[0, 0], nodes='state_input'))
p.set_val('traj.burn2.states:vt',
value=burn2.interpolate(ys=[1, np.sqrt(1 / r_target)],
nodes='state_input'))
p.set_val('traj.burn2.states:deltav',
value=burn2.interpolate(ys=[0.1, 0.2],
nodes='state_input'))
p.set_val('traj.burn2.states:accel',
value=burn2.interpolate(ys=[0.1, 0],
nodes='state_input'))
p.set_val('traj.burn2.controls:u1',
value=burn2.interpolate(ys=[0, 0], nodes='control_input'))
p.run_driver()
return p
root.connect('p1.x','my_comp.x' )
root.connect('p2.y', 'my_comp.y')
root.connect('my_comp.x', 'con.x')
root.connect('my_comp.y', 'con.y')
top.driver = ScipyOptimizer()
top.driver.options['optimizer'] = 'SLSQP'
top.driver.add_desvar('p1.x',lower = -50,upper = 50)
top.driver.add_desvar('p2.y', lower = -50, upper =50)
top.driver.add_objective('my_comp.f_xy')
top.driver.add_constraint('con.c', lower = 15.0, upper = 16)
recorder = SqliteRecorder('Parabola')
recorder.options['record_params'] = True
recorder.options['record_metadata'] = True
top.driver.add_recorder(recorder)
top.setup()
top.run()
top.cleanup()
print('\n')
print'Minimum of %s found at (%s,%s)' %(top['my_comp.f_xy'],top['my_comp.x'],top['my_comp.y'])
def test(self):
import numpy as np
from openmdao.api import IndepVarComp, Problem, Group, NewtonSolver, \
ScipyIterativeSolver, LinearBlockGS, NonlinearBlockGS, \
DirectSolver, LinearBlockGS, PetscKSP, SqliteRecorder
from openaerostruct.geometry.utils import generate_mesh
from openaerostruct.geometry.geometry_group import Geometry
from openaerostruct.aerodynamics.aero_groups import AeroPoint
# Create a dictionary to store options about the mesh
mesh_dict = {
'num_y': 7,
'num_x': 2,
'wing_type': 'CRM',
'symmetry': True,
'num_twist_cp': 5
}
# Generate the aerodynamic mesh based on the previous dictionary
mesh, twist_cp = generate_mesh(mesh_dict)
# Create a dictionary with info and options about the aerodynamic
# lifting surface
surface = {
# Wing definition
'name': 'wing', # name of the surface
'type': 'aero',
'symmetry': True, # if true, model one half of wing
# reflected across the plane y = 0
'S_ref_type': 'wetted', # how we compute the wing area,
# can be 'wetted' or 'projected'
'fem_model_type': 'tube',
'twist_cp': twist_cp,
'mesh': mesh,
'num_x': mesh.shape[0],
'num_y': mesh.shape[1],
# Aerodynamic performance of the lifting surface at
# an angle of attack of 0 (alpha=0).
# These CL0 and CD0 values are added to the CL and CD
# obtained from aerodynamic analysis of the surface to get
# the total CL and CD.
# These CL0 and CD0 values do not vary wrt alpha.
'CL0': 0.0, # CL of the surface at alpha=0
'CD0': 0.015, # CD of the surface at alpha=0
# Airfoil properties for viscous drag calculation
'k_lam': 0.05, # percentage of chord with laminar
# flow, used for viscous drag
't_over_c': 0.15, # thickness over chord ratio (NACA0015)
'c_max_t': .303, # chordwise location of maximum (NACA0015)
# thickness
'with_viscous': True, # if true, compute viscous drag
}
# Create the OpenMDAO problem
prob = Problem()
# Create an independent variable component that will supply the flow
# conditions to the problem.
indep_var_comp = IndepVarComp()
indep_var_comp.add_output('v', val=248.136, units='m/s')
indep_var_comp.add_output('alpha', val=5., units='deg')
indep_var_comp.add_output('M', val=0.84)
indep_var_comp.add_output('re', val=1.e6, units='1/m')
indep_var_comp.add_output('rho', val=0.38, units='kg/m**3')
indep_var_comp.add_output('cg', val=np.zeros((3)), units='m')
# Add this IndepVarComp to the problem model
prob.model.add_subsystem('prob_vars', indep_var_comp, promotes=['*'])
# Create and add a group that handles the geometry for the
# aerodynamic lifting surface
geom_group = Geometry(surface=surface)
prob.model.add_subsystem(surface['name'], geom_group)
# Create the aero point group, which contains the actual aerodynamic
# analyses
aero_group = AeroPoint(surfaces=[surface])
point_name = 'aero_point_0'
prob.model.add_subsystem(
point_name,
aero_group,
promotes_inputs=['v', 'alpha', 'M', 're', 'rho', 'cg'])
name = surface['name']
# Connect the mesh from the geometry component to the analysis point
prob.model.connect(name + '.mesh',
point_name + '.' + name + '.def_mesh')
# Perform the connections with the modified names within the
# 'aero_states' group.
prob.model.connect(name + '.mesh',
point_name + '.aero_states.' + name + '_def_mesh')
# Import the Scipy Optimizer and set the driver of the problem to use
# it, which defaults to an SLSQP optimization method
from openmdao.api import ScipyOptimizeDriver
prob.driver = ScipyOptimizeDriver()
prob.driver.options['tol'] = 1e-9
recorder = SqliteRecorder("aero.db")
prob.driver.add_recorder(recorder)
prob.driver.recording_options['record_derivatives'] = True
# Setup problem and add design variables, constraint, and objective
prob.model.add_design_var('wing.twist_cp', lower=-10., upper=15.)
prob.model.add_constraint(point_name + '.wing_perf.CL', equals=0.5)
prob.model.add_objective(point_name + '.wing_perf.CD', scaler=1e4)
# Set up and run the optimization problem
prob.setup()
prob.run_model()
# prob.check_partials(compact_print=True)
# exit()
prob.run_driver()
assert_rel_error(self, prob['aero_point_0.wing_perf.CD'][0],
0.033389699871650073, 1e-6)
assert_rel_error(self, prob['aero_point_0.wing_perf.CL'][0], 0.5, 1e-6)
assert_rel_error(self, prob['aero_point_0.CM'][1],
-0.18451822790794759, 1e-6)
