import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, ExecComp, ScipyOptimizeDriver
from wingWeight import wingWeightComp
prob = Problem()
model = Group()
comp = IndepVarComp()
comp.add_output('W0', val=50000)
comp.add_output('Swing', val=1000)
comp.add_design_var('W0', lower=30000)
model.add_subsystem('inputs_comp', comp, promotes=['*'])
comp = wingWeightComp(N=3.,tc=0.3,AR=9.,sweep=30.)
model.add_subsystem('wingWeight', comp, promotes=['*'])
comp = ExecComp('totalWeight = Wwing')
comp.add_objective('totalWeight', scaler=40000.)
model.add_subsystem('total_comp', comp, promotes=['*'])
prob.model = model
prob.driver = ScipyOptimizeDriver()
prob.driver.options['optimizer'] = 'SLSQP'
def setup(self):
ground_station = self.options['ground_station']
num_times = self.options['num_times']
num_cp = self.options['num_cp']
step_size = self.options['step_size']
mtx = self.options['mtx']
comp = IndepVarComp()
comp.add_output('P_comm_cp', val=0.25 * np.ones(num_cp), units='W')
comp.add_design_var('P_comm_cp', lower=0., upper=100.)
comp.add_output('gain', val=16.0 * np.ones(num_times))
comp.add_output('Initial_Data', val=0.0)
for var_name in [
'lon',
'lat',
'alt',
'antAngle',
]:
comp.add_output(var_name, val=ground_station[var_name])
self.add_subsystem('inputs_comp', comp, promotes=['*'])
comp = EarthSpinComp(num_times=num_times)
self.add_subsystem('q_E', comp, promotes=['*'])
comp = EarthspinRotationMtx(num_times=num_times)
self.add_subsystem('Rot_ECI_EF', comp, promotes=['*'])
comp = GS_ECEF_Comp(num_times=num_times)
self.add_subsystem('r_e2g_E', comp, promotes=['*'])
comp = GS_ECI_Comp(num_times=num_times)
self.add_subsystem('r_e2g_I', comp, promotes=['*'])
comp = Comm_VectorECI(num_times=num_times)
self.add_subsystem('r_b2g_I', comp, promotes=['*'])
comp = CommLOSComp(num_times=num_times)
self.add_subsystem('CommLOS', comp, promotes=['*'])
comp = VectorBodyComp(num_times=num_times)
self.add_subsystem('r_b2g_B', comp, promotes=['*'])
comp = AntRotationComp(num_times=num_times)
self.add_subsystem('q_A', comp, promotes=['*'])
comp = AntennaRotationMtx(num_times=num_times)
self.add_subsystem('Rot_AB', comp, promotes=['*'])
comp = AntennaBodyComp(num_times=num_times)
self.add_subsystem('r_b2g_A', comp, promotes=['*'])
comp = StationSatelliteDistanceComp(num_times=num_times)
self.add_subsystem('Gsdist', comp, promotes=['*'])
comp = BsplineComp(
num_pt=num_times,
num_cp=num_cp,
jac=mtx,
in_name='P_comm_cp',
out_name='P_comm',
)
self.add_subsystem('P_comm_comp', comp, promotes=['*'])
comp = BitRateComp(num_times=num_times)
self.add_subsystem('Download_rate', comp, promotes=['*'])
comp = DataDownloadComp(
num_times=num_times,
step_size=step_size,
)
self.add_subsystem('Data_download_rk4_comp', comp, promotes=['*'])
comp = ExecComp(
'total_data_downloaded= Data[-1] - Data[0]',
Data=np.empty(num_times),
)
self.add_subsystem('total_data_downloaded_comp', comp, promotes=['*'])
def setup(self):
shape = self.options['shape']
#
comp = IndepVarComp()
# Initial values for optimization:
# Adding Input variables which are the outputs of input_comp
# Atmospheric inital values:
comp.add_output('v_inf' , val= 67)
comp.add_output('q' , val= 250)
# Wing inital values:
comp.add_output('wing_alpha', val = 0.015)
comp.add_output('wing_CLa', val = 2*np.pi)
comp.add_output('wing_CL0', val = 0.2)
comp.add_output('wing_CD0', val = 0.015)
comp.add_output('wing_e', val = 0.85)
comp.add_output('wing_AR', val = 12 )
comp.add_output('wing_area', val = 25 )
comp.add_output('wing_tc', val = 0.12 )
comp.add_output('nose_wing_c4', val = 2.1336)
# Tail inital values:
comp.add_output('tail_alpha', val = 0.04)
comp.add_output('tail_CLa', val = 2*np.pi)
comp.add_output('tail_CL0', val = 0.2)
comp.add_output('tail_CD0', val = 0.015)
comp.add_output('tail_e', val = 0.85)
comp.add_output('tail_AR', val = 12 )
comp.add_output('tail_area', val = 4 )
comp.add_output('tail_tc', val = 0.12)
comp.add_output('nose_tail_c4', val = 6.5292)
comp.add_output('total_area', val = 29)
# Fuselage initial values:
comp.add_output('fuselage_max_crossec_area', val = 7.22)
comp.add_output('fuselage_length', val = 6.4)
comp.add_output('fuselage_f', val = 2.11)
comp.add_output('fuselage_form_factor', val = 7.3847)
comp.add_output('fuselage_wetted_area', val = 52.05)
# Vertical tail initial values:
comp.add_output('vertical_tail_mac', val = 1.074)
comp.add_output('vertical_tail_tc', val = 0.188)
comp.add_output('vertical_tail_area', val = 1.625803)
# Propeller inital values:
comp.add_output('wing_prop_inner_rad',val = 0.8)
comp.add_output('wing_prop_outer_rad',val = 0.8)
comp.add_output('tail_prop_rad',val = 0.8)
# Weights initial values:
comp.add_output('w_design', val=26700.)
comp.add_output('w_pax', val=900.)
comp.add_output('w_else', val=18000.) # all empty weight EXCEPT tail, wing, PAX
comp.add_output('load_factor', val=3.8)
comp.add_output('x_wingc4', val=2.1336)
comp.add_output('x_tailc4', val=6.5292)
comp.add_output('x_else', val=3.)
comp.add_output('x_pax', val=1.088136)
comp.add_output('MAC', val=1.)
comp.add_output('w_tail')
# Battery/Energy Initial Values:
comp.add_output('battery_mass', val = 500.)
comp.add_output('batter_energy_density', val = 300.)
comp.add_output('range', val = 140.)
# Economics initial values:
comp.add_output('EngRt' , val= 40)
comp.add_output('MfgRt' , val= 30)
comp.add_output('ToolRt' , val= 21)
comp.add_output('QcRt' , val= 37)
comp.add_output('kwh' , val= 133)
comp.add_output('kwhcost' , val= 137)
comp.add_output('num_motor' , val= 6)
comp.add_output('quantity' , val= 250)
comp.add_output('Price_km' , val= 2)
comp.add_output('cost_km' , val= 1.25)
comp.add_output('EnergyCost' , val= .12)
comp.add_output('flthr_yr' , val= 2000)
comp.add_output('years' , val= 5)
comp.add_output('t_tol' , val= 1/36)
comp.add_output('distance' , val= 20000)
comp.add_output('savings' , val= .6985)
comp.add_output('v_drive' , val= 31.2)
# comp.add_output('trip_length', 20000.)
# comp.add_output('hover_time', 100.)
# ----- ----- ----- ----- SETTING BOUNDS FOR DESIGN VARIABLES ----- ----- ----- ----- #
comp.add_design_var('v_inf', lower = 60, upper = 70)
# comp.add_design_var('wing_alpha', lower = 0,upper = 0.15)
# comp.add_design_var('wing_AR', lower=8., upper = 15.)
# comp.add_design_var('wing_area', lower=20., upper = 30.)
comp.add_design_var('battery_mass', lower = 450, upper = 600)
# SETTING THE REST LATER ONE AT A TIME
self.add_subsystem('inputs_comp', comp, promotes=['*'])
def setup(self):
fem_solver = self.options['fem_solver']
force = self.options['force']
num_elem_x = self.options['num_elem_x']
num_elem_y = self.options['num_elem_y']
p = self.options['penal']
volume_fraction = self.options['volume_fraction']
(nodes, elem, elem_dof) = fem_solver.get_mesh()
(length_x, length_y) = (np.max(nodes[:, 0], 0), np.max(nodes[:, 1], 0))
(num_nodes_x, num_nodes_y) = (num_elem_x + 1, num_elem_y + 1)
nNODE = num_nodes_x * num_nodes_y
nELEM = (num_nodes_x - 1) * (num_nodes_y - 1)
nDOF = nNODE * 2
rhs = force
# inputs
comp = IndepVarComp()
comp.add_output('rhs', val=rhs)
comp.add_output('dvs', val=0.8, shape=nELEM)
comp.add_design_var('dvs', lower=0.01, upper=1.0)
# comp.add_design_var('x', lower=-4, upper=4) // param
self.add_subsystem('inputs_comp', comp)
self.connect('inputs_comp.dvs', 'filter_comp.dvs')
self.connect('inputs_comp.rhs', 'states_comp.rhs')
# density filter
comp = DensityFilterComp(length_x=length_x,
length_y=length_y,
num_nodes_x=num_nodes_x,
num_nodes_y=num_nodes_y,
num_dvs=nELEM,
radius=length_x / (float(num_nodes_x) - 1) *
2)
self.add_subsystem('filter_comp', comp)
self.connect('filter_comp.dvs_bar', 'penalization_comp.x')
self.connect('filter_comp.dvs_bar', 'weight_comp.x')
# penalization
comp = PenalizationComp(num=nELEM, p=p)
self.add_subsystem('penalization_comp', comp)
self.connect('penalization_comp.y', 'states_comp.multipliers')
# states
comp = StatesComp(fem_solver=fem_solver,
num_nodes_x=num_nodes_x,
num_nodes_y=num_nodes_y,
isSIMP=True)
self.add_subsystem('states_comp', comp)
self.connect('states_comp.states', 'disp_comp.states')
# num_states to num_dofs
comp = DispComp(num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y)
self.add_subsystem('disp_comp', comp)
self.connect('disp_comp.disp', 'compliance_comp.disp')
comp = DispComp(num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y)
self.add_subsystem('GF_comp', comp)
self.connect('inputs_comp.rhs', 'GF_comp.states')
self.connect('GF_comp.disp', 'compliance_comp.forces')
# compliance
comp = ComplianceComp(num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y)
self.add_subsystem('compliance_comp', comp)
# self.connect('inputs_comp.rhs', 'compliance_comp.forces')
# weight
comp = WeightComp(num=nELEM)
comp.add_constraint('weight', upper=volume_fraction)
self.add_subsystem('weight_comp', comp)
# objective
comp = ObjectiveComp(w=0.0)
comp.add_objective('objective')
self.add_subsystem('objective_comp', comp)
self.connect('compliance_comp.compliance', 'objective_comp.compliance')
self.connect('weight_comp.weight', 'objective_comp.weight')
def setup(self):
num_times = self.options['num_times']
num_cp = self.options['num_cp']
cubesat = self.options['cubesat']
mtx = self.options['mtx']
comp = IndepVarComp()
# comp.add_output('roll_cp', val=2. * np.pi * np.random.rand(num_cp))
# comp.add_output('pitch_cp', val=2. * np.pi * np.random.rand(num_cp))
comp.add_output('roll_cp', val=np.ones(num_cp))
comp.add_output('pitch_cp', val=np.ones(num_cp))
comp.add_design_var('roll_cp')
comp.add_design_var('pitch_cp')
self.add_subsystem('inputs_comp', comp, promotes=['*'])
for var_name in ['roll', 'pitch']:
comp = BsplineComp(
num_pt=num_times,
num_cp=num_cp,
jac=mtx,
in_name='{}_cp'.format(var_name),
out_name=var_name,
)
self.add_subsystem('{}_comp'.format(var_name),
comp,
promotes=['*'])
comp = RotMtxBIComp(num_times=num_times)
self.add_subsystem('rot_mtx_b_i_3x3xn_comp', comp, promotes=['*'])
comp = ArrayReorderComp(
in_shape=(3, 3, num_times),
out_shape=(3, 3, num_times),
in_subscripts='ijn',
out_subscripts='jin',
in_name='rot_mtx_b_i_3x3xn',
out_name='rot_mtx_i_b_3x3xn',
)
self.add_subsystem('rot_mtx_i_b_3x3xn_comp', comp, promotes=['*'])
#
for var_name in [
'times',
'roll',
'pitch',
]:
comp = FiniteDifferenceComp(
num_times=num_times,
in_name=var_name,
out_name='d{}'.format(var_name),
)
self.add_subsystem('d{}_comp'.format(var_name),
comp,
promotes=['*'])
rad_deg = np.pi / 180.
for var_name in [
'roll',
'pitch',
]:
comp = PowerCombinationComp(shape=(num_times, ),
out_name='{}_rate'.format(var_name),
powers_dict={
'd{}'.format(var_name): 1.,
'dtimes': -1.,
})
comp.add_constraint('{}_rate'.format(var_name),
lower=-10. * rad_deg,
upper=10. * rad_deg,
linear=True)
self.add_subsystem('{}_rate_comp'.format(var_name),
comp,
promotes=['*'])
def setup(self):
fem_solver = self.metadata['fem_solver']
length_x = self.metadata['length_x']
length_y = self.metadata['length_y']
num_nodes_x = self.metadata['num_nodes_x']
num_nodes_y = self.metadata['num_nodes_y']
num_param_x = self.metadata['num_param_x']
num_param_y = self.metadata['num_param_y']
forces = self.metadata['forces']
p = self.metadata['p']
w = self.metadata['w']
nodes = self.metadata['nodes']
quad_order = self.metadata['quad_order']
volume_fraction = self.metadata['volume_fraction']
num = num_nodes_x * num_nodes_y
coord_eval_x, coord_eval_y = get_coord_eval(num_nodes_x, num_nodes_y,
quad_order)
coord_eval_x *= length_x
coord_eval_y *= length_y
gpt_mesh = np.zeros((coord_eval_x.shape[0], coord_eval_y.shape[0], 2))
gpt_mesh[:, :, 0] = np.outer(coord_eval_x,
np.ones(coord_eval_y.shape[0]))
gpt_mesh[:, :, 1] = np.outer(np.ones(coord_eval_x.shape[0]),
coord_eval_y)
state_size = 2 * num_nodes_x * num_nodes_y + 2 * num_nodes_y
disp_size = 2 * num_nodes_x * num_nodes_y
coord_eval_x, coord_eval_y = get_coord_eval(num_nodes_x, num_nodes_y,
quad_order)
if 1:
param_mtx = get_bspline_mtx(coord_eval_x,
coord_eval_y,
num_param_x,
num_param_y,
kx=4,
ky=4)
else:
param_mtx = get_rbf_mtx(coord_eval_x,
coord_eval_y,
num_param_x,
num_param_y,
kx=4,
ky=4)
rhs = np.zeros(state_size)
rhs[:disp_size] = forces
# inputs
comp = IndepVarComp()
comp.add_output('rhs', val=rhs)
comp.add_output('forces', val=forces)
# x = np.linalg.solve(
# param_mtx.T.dot(param_mtx),
# param_mtx.T.dot(0.5 * np.ones((num_nodes_x - 1) * (num_nodes_y - 1))))
comp.add_output('dvs', val=0., shape=num_param_x * num_param_y)
comp.add_design_var('dvs')
self.add_subsystem('inputs_comp', comp)
self.connect('inputs_comp.dvs', 'parametrization_comp.x')
comp = ParametrizationComp(
mtx=param_mtx,
num_rows=(num_nodes_x - 1) * (num_nodes_y - 1) * quad_order**2,
num_cols=num_param_x * num_param_y,
)
self.add_subsystem('parametrization_comp', comp)
self.connect('parametrization_comp.y', 'states_comp.plot_var')
# if 0:
# self.connect('parametrization_comp.y', 'averaging_comp.x')
# comp = AveragingComp(
# num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y, quad_order=quad_order)
# self.add_subsystem('averaging_comp', comp)
# self.connect('averaging_comp.y', 'heaviside_comp.x')
#
# comp = HeavisideComp(num=num)
# self.add_subsystem('heaviside_comp', comp)
# self.connect('heaviside_comp.y', 'penalization_comp.x')
# self.connect('heaviside_comp.y', 'weight_comp.x')
#
# comp = PenalizationComp(num=num, p=p)
# self.add_subsystem('penalization_comp', comp)
# self.connect('penalization_comp.y', 'states_comp.multipliers')
if 1:
self.connect('parametrization_comp.y', 'heaviside_comp.x')
comp = HeavisideComp(num=(num_nodes_x - 1) * (num_nodes_y - 1) *
quad_order**2)
self.add_subsystem('heaviside_comp', comp)
self.connect('heaviside_comp.y', 'averaging_comp.x')
self.connect('heaviside_comp.y', 'states_comp.plot_var2')
comp = AveragingComp(num_nodes_x=num_nodes_x,
num_nodes_y=num_nodes_y,
quad_order=quad_order)
self.add_subsystem('averaging_comp', comp)
self.connect('averaging_comp.y', 'penalization_comp.x')
self.connect('averaging_comp.y', 'weight_comp.x')
comp = PenalizationComp(num=num, p=p)
self.add_subsystem('penalization_comp', comp)
self.connect('penalization_comp.y', 'states_comp.multipliers')
else:
self.connect('parametrization_comp.y', 'heaviside_comp.x')
comp = HeavisideComp(num=(num_nodes_x - 1) * (num_nodes_y - 1) *
quad_order**2)
self.add_subsystem('heaviside_comp', comp)
self.connect('heaviside_comp.y', 'penalization_comp.x')
self.connect('heaviside_comp.y', 'averaging_comp2.x')
self.connect('heaviside_comp.y', 'states_comp.plot_var2')
comp = AveragingComp(num_nodes_x=num_nodes_x,
num_nodes_y=num_nodes_y,
quad_order=quad_order)
self.add_subsystem('averaging_comp2', comp)
self.connect('averaging_comp2.y', 'weight_comp.x')
comp = PenalizationComp(num=(num_nodes_x - 1) * (num_nodes_y - 1) *
quad_order**2,
p=p)
self.add_subsystem('penalization_comp', comp)
self.connect('penalization_comp.y', 'averaging_comp.x')
comp = AveragingComp(num_nodes_x=num_nodes_x,
num_nodes_y=num_nodes_y,
quad_order=quad_order)
self.add_subsystem('averaging_comp', comp)
self.connect('averaging_comp.y', 'states_comp.multipliers')
# states
comp = StatesComp(fem_solver=fem_solver,
num_nodes_x=num_nodes_x,
num_nodes_y=num_nodes_y,
nodes=nodes,
gpt_mesh=gpt_mesh,
quad_order=quad_order)
self.add_subsystem('states_comp', comp)
self.connect('inputs_comp.rhs', 'states_comp.rhs')
# disp
comp = DispComp(num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y)
self.add_subsystem('disp_comp', comp)
self.connect('states_comp.states', 'disp_comp.states')
# compliance
comp = ComplianceComp(num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y)
self.add_subsystem('compliance_comp', comp)
self.connect('disp_comp.disp', 'compliance_comp.disp')
self.connect('inputs_comp.forces', 'compliance_comp.forces')
# weight
comp = WeightComp(num=num)
comp.add_constraint('weight', upper=volume_fraction)
self.add_subsystem('weight_comp', comp)
# objective
comp = ObjectiveComp(w=w)
comp.add_objective('objective')
self.add_subsystem('objective_comp', comp)
self.connect('compliance_comp.compliance', 'objective_comp.compliance')
self.connect('weight_comp.weight', 'objective_comp.weight')
geometry=geometry,
analyses=analyses,
aircraft_type='transport',
)
prob = Problem()
comp = IndepVarComp()
comp.add_output('speed', val=250., lower=200., upper = 300.) # units='m/s' , val=250.
comp.add_output('altitude', val=7., lower=4., upper = 14.)# units = 'km' , val=7
comp.add_output('ref_mac', val=7., lower=4., upper = 14.) # , val=7.
comp.add_output('alpha', val=3. * np.pi / 180., lower=0.* np.pi / 180., upper = 5.* np.pi / 180.)# , val=3. * np.pi / 180.
comp.add_output('ref_area', val=427.8,lower=200., upper = 800.) # , val=427.8
comp.add_output('empty_weight_fraction',val=0.5,lower=0.45, upper =0.55)
comp.add_design_var('speed', lower=200., upper = 300.) # units='m/s' , val=250.
comp.add_design_var('altitude',lower=4., upper = 14.)# units = 'km' , val=7
comp.add_design_var('ref_mac', lower=4., upper = 14.) # , val=7.
comp.add_design_var('alpha', lower=0., upper = 5.* np.pi / 180.)# , val=3. * np.pi / 180.
comp.add_design_var('ref_area',lower=200., upper = 800.) # , val=427.8
comp.add_design_var('empty_weight_fraction',lower=0.45, upper =0.55)
prob.model.add_subsystem('opt_input_comp', comp, promotes=['*'])
comp = IndepVarComp()
comp.add_output('large_production_quentity',val=1600)#constant production plan in 10 years (1600)
comp.add_output('learning_curve',val=0.8) #constant learning curve effect 60%~95%
comp.add_output('mission_year',val=100) #constant missions per year
comp.add_output('passenger',val=400)
comp.add_output('ticket_price',val=100)
#fix these?
comp.add_output('R',val=6500,units='km') #range
def setup(self):
num_times = self.options['num_times']
num_cp = self.options['num_cp']
step_size = self.options['step_size']
# cubesat = self.options['cubesat']
mtx = self.options['mtx']
Ground_station = self.options['Ground_station']
name = Ground_station['name']
comm_times = np.linspace(0., step_size * (num_times - 1), num_times)
comp = IndepVarComp()
comp.add_output('lon', val=Ground_station['lon'], units='rad')
comp.add_output('lat', val=Ground_station['lat'], units='rad')
comp.add_output('alt', val=Ground_station['alt'], units='km')
comp.add_output('comm_times', units='s', val=comm_times)
comp.add_output('antAngle', val=1.6, units='rad')
# comp.add_design_var('antAngle', lower=0., upper=10000)
comp.add_output('P_comm_cp', val=13.0 * np.ones(num_cp), units='W')
comp.add_design_var('P_comm_cp', lower=0., upper=20.0)
comp.add_output('gain', val=16.0 * np.ones(num_times))
comp.add_output('Initial_Data', val=0.0)
self.add_subsystem('inputs_comp', comp, promotes=['*'])
comp = EarthSpinComp(num_times=num_times)
self.add_subsystem('q_E', comp, promotes=['*'])
comp = EarthspinRotationMtx(num_times=num_times)
self.add_subsystem('Rot_ECI_EF', comp, promotes=['*'])
comp = GS_ECEF_Comp(num_times=num_times)
self.add_subsystem('r_e2g_E', comp, promotes=['*'])
comp = GS_ECI_Comp(num_times=num_times)
self.add_subsystem('r_e2g_I', comp, promotes=['*'])
comp = Comm_VectorECI(num_times=num_times)
self.add_subsystem('r_b2g_I', comp, promotes=['*'])
comp = CommLOSComp(num_times=num_times)
self.add_subsystem('CommLOS', comp, promotes=['*'])
comp = VectorBodyComp(num_times=num_times)
self.add_subsystem('r_b2g_B', comp, promotes=['*'])
comp = AntRotationComp(num_times=num_times)
self.add_subsystem('q_A', comp, promotes=['*'])
comp = AntennaRotationMtx(num_times=num_times)
self.add_subsystem('Rot_AB', comp, promotes=['*'])
comp = AntennaBodyComp(num_times=num_times)
self.add_subsystem('r_b2g_A', comp, promotes=['*'])
comp = StationSatelliteDistanceComp(num_times=num_times)
self.add_subsystem('Gsdist', comp, promotes=['*'])
comp = BsplineComp(
num_pt=num_times,
num_cp=num_cp,
jac=mtx,
in_name='P_comm_cp',
out_name='P_comm',
)
self.add_subsystem('P_comm_comp', comp, promotes=['*'])
comp = BitRateComp(num_times=num_times)
self.add_subsystem('Download_rate', comp, promotes=['*'])
# comp = DataDownloadComp(
# num_times=num_times,
# step_size=step_size,
# )
# self.add_subsystem('Data_download_rk4_comp', comp, promotes=['*'])
# comp = ExecComp(
# 'total_data_downloaded= Data[-1] - Data[0]',
# Data=np.empty(num_times),
# )
# self.add_subsystem('total_data_downloaded_comp', comp, promotes=['*'])
def setup(self):
num_times = self.options['num_times']
num_cp = self.options['num_cp']
step_size = self.options['step_size']
cubesat = self.options['cubesat']
mtx = self.options['mtx']
shape = (3, num_times)
thrust_unit_vec = np.outer(
np.array([1., 0., 0.]),
np.ones(num_times),
)
comp = IndepVarComp()
comp.add_output('thrust_unit_vec_b_3xn', val=thrust_unit_vec)
comp.add_output('thrust_scalar_mN_cp', val=1.e-3 * np.ones(num_cp))
comp.add_output('initial_propellant_mass', 0.17)
comp.add_design_var('thrust_scalar_mN_cp', lower=0., upper=20000)
self.add_subsystem('inputs_comp', comp, promotes=['*'])
comp = MtxVecComp(
num_times=num_times,
mtx_name='rot_mtx_i_b_3x3xn',
vec_name='thrust_unit_vec_b_3xn',
out_name='thrust_unit_vec_3xn',
)
self.add_subsystem('thrust_unit_vec_3xn_comp', comp, promotes=['*'])
comp = LinearCombinationComp(
shape=(num_cp, ),
out_name='thrust_scalar_cp',
coeffs_dict=dict(thrust_scalar_mN_cp=1.e-3),
)
self.add_subsystem('thrust_scalar_cp_comp', comp, promotes=['*'])
comp = BsplineComp(
num_pt=num_times,
num_cp=num_cp,
jac=mtx,
in_name='thrust_scalar_cp',
out_name='thrust_scalar',
)
self.add_subsystem('thrust_scalar_comp', comp, promotes=['*'])
comp = ArrayExpansionComp(
shape=shape,
expand_indices=[0],
in_name='thrust_scalar',
out_name='thrust_scalar_3xn',
)
self.add_subsystem('thrust_scalar_3xn_comp', comp, promotes=['*'])
comp = PowerCombinationComp(
shape=shape,
out_name='thrust_3xn',
powers_dict=dict(
thrust_unit_vec_3xn=1.,
thrust_scalar_3xn=1.,
),
)
self.add_subsystem('thrust_3xn_comp', comp, promotes=['*'])
comp = LinearCombinationComp(
shape=(num_times, ),
out_name='mass_flow_rate',
coeffs_dict=dict(thrust_scalar=-1. /
(cubesat['acceleration_due_to_gravity'] *
cubesat['specific_impulse'])))
self.add_subsystem('mass_flow_rate_comp', comp, promotes=['*'])
comp = PropellantMassRK4Comp(
num_times=num_times,
step_size=step_size,
)
self.add_subsystem('propellant_mass_rk4_comp', comp, promotes=['*'])
comp = ExecComp(
'total_propellant_used=propellant_mass[0] - propellant_mass[-1]',
propellant_mass=np.empty(num_times),
)
self.add_subsystem('total_propellant_used_comp', comp, promotes=['*'])
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, ExecComp, ScipyOptimizeDriver
from simple_optimization.components.cl_comp import CLComp
from simple_optimization.components.cdi_comp import CDiComp
prob = Problem()
model = Group()
comp = IndepVarComp()
comp.add_output('alpha', val=0.04)
comp.add_output('CLa', val=2 * np.pi)
comp.add_output('CL0', val=0.2)
comp.add_output('CD0', val=0.015)
comp.add_output('AR', val=8.)
comp.add_design_var('alpha', lower=0.)
model.add_subsystem('inputs_comp', comp, promotes=['*'])
comp = CLComp()
model.add_subsystem('cl_comp', comp, promotes=['*'])
e = 0.7
if 1:
comp = CDiComp(e=e)
model.add_subsystem('cdi_comp', comp, promotes=['*'])
else:
from lsdo_utils.api import PowerCombinationComp
comp = PowerCombinationComp(shape=(1, ),
out_name='CDi',
coeff=1. / np.pi / e,
powers_dict=dict(
def setup(self):
fe_model = self.options['fe_model']
nelx = self.options['num_ele_x']
nely = self.options['num_ele_y']
penal = self.options['penal_factor']
volume_fraction = self.options['volume_fraction']
radius = self.options['filter_radius']
max_buckling_load = self.options['max_buckling_load']
initial_x = self.options['initial_densities']
data_recorder = self.options['data_recorder']
# Check FEA assembly and evaluate dimensions of the sparse matrix
n_elements = nelx * nely
n_dof = 2 * (nelx + 1) * (nely + 1)
unknown_dof = fe_model.unknown_dof
# Inside default parameters
n_eigenvalues = 5
eigenvalue_gap = 1.01
#aggregation_parameter = 30.0
minimum_x = 1e-6
# Setup design variables ['densities']
comp = IndepVarComp()
comp.add_output('densities', val=initial_x, shape=n_elements)
comp.add_design_var('densities', lower=0.0, upper=1.0)
self.add_subsystem('input_comp', comp)
self.connect('input_comp.densities', 'filter_comp.densities')
# self.connect('input_comp.densities',
# 'penalization_comp.densities')
# self.connect('input_comp.densities',
# 'volume_comp.densities')
# Density Filter
comp = DensityFilterComp(num_ele_x=nelx, num_ele_y=nely, radius=radius)
self.add_subsystem('filter_comp', comp)
self.connect('filter_comp.densities_f', 'penalization_comp.densities')
self.connect('filter_comp.densities_f', 'volume_comp.densities')
# Penalization
comp = PenalizationComp(penal=penal, n_elements=n_elements)
self.add_subsystem('penalization_comp', comp)
self.connect('penalization_comp.multipliers',
'buckling_comp.multipliers')
self.connect('penalization_comp.multipliers',
'states_comp.multipliers')
## STATES COMP
comp = States_comp(number_of_elements=n_elements,
number_of_dof=n_dof,
finite_elements_model=fe_model,
minimum_x=minimum_x)
self.add_subsystem('states_comp', comp)
self.connect('states_comp.states', 'compliance_comp.displacements')
self.connect('states_comp.states', 'buckling_comp.states')
## BUCKLING COMP
comp = BucklingComp(number_of_dof=n_dof,
number_of_elements=n_elements,
number_of_eigenvalues=n_eigenvalues,
finite_elements_model=fe_model,
minimum_x=minimum_x)
self.add_subsystem('buckling_comp', comp)
self.connect('buckling_comp.critical_loads',
'buckling_constraint_comp.eigenvalues')
# Compliance
comp = ComplianceComp(fe_model=fe_model,
ndof=n_dof,
unknown_dof=unknown_dof,
data_recorder=data_recorder)
self.add_subsystem('compliance_comp', comp)
# Volume
comp = VolumeComp(nelements=n_elements, data_recorder=data_recorder)
self.add_subsystem('volume_comp', comp)
# Buckling Constraint Comp - Direct engenvalues
comp = BucklingConstraint(eigenvalue_gap=eigenvalue_gap,
max_buckling_load=max_buckling_load,
number_of_eigenvalues=n_eigenvalues,
data_recorder=data_recorder)
self.add_subsystem('buckling_constraint_comp', comp)
# Buckling Constraint Comp - Aggregation
# comp = AggregationConstraint(aggregation_parameter=aggregation_parameter,
# max_buckling_load=max_buckling_load,
# number_of_eigenvalues=n_eigenvalues)
# self.add_subsystem('aggregation_constraint_comp', comp)
# Design variables
#self.add_design_var('input_comp.densities', upper=1)
# Objective
#self.add_objective('volume_comp.volume')
self.add_objective('compliance_comp.compliance')
# Constraints:
self.add_constraint('volume_comp.volume',
upper=volume_fraction,
linear=True)
#self.add_constraint('aggregation_constraint_comp.residuals', lower=0)
self.add_constraint('buckling_constraint_comp.residuals', lower=0)
def setup(self):
shape = self.options['shape']
aircraft = self.options['aircraft']
comp = IndepVarComp()
comp.add_output('CL_max', val=aircraft['CL_max'], shape=shape)
comp.add_output('CL_takeoff', val=aircraft['CL_takeoff'], shape=shape)
comp.add_output('climb_gradient',
val=aircraft['climb_gradient'],
shape=shape)
comp.add_output('turn_load_factor',
val=aircraft['turn_load_factor'],
shape=shape)
comp.add_output('TOP', val=aircraft['TOP'], shape=shape)
comp.add_output('takeoff_density',
val=aircraft['takeoff_density'],
shape=shape)
comp.add_output('sealevel_density', val=1.225, shape=shape)
comp.add_output('stall_speed',
val=aircraft['stall_speed'],
shape=shape)
comp.add_output('climb_speed',
val=aircraft['climb_speed'],
shape=shape)
comp.add_output('turn_speed', val=aircraft['turn_speed'], shape=shape)
comp.add_output('landing_distance',
val=aircraft['landing_distance'],
shape=shape)
comp.add_output('approach_distance',
val=aircraft['approach_distance'],
shape=shape)
comp.add_output('wing_loading',
val=aircraft['wing_loading'],
shape=shape)
comp.add_output('thrust_to_weight',
val=aircraft['thrust_to_weight'],
shape=shape)
comp.add_output('ref_wing_loading',
val=aircraft['ref_wing_loading'],
shape=shape)
comp.add_output('ref_thrust_to_weight',
val=aircraft['ref_thrust_to_weight'],
shape=shape)
comp.add_design_var('wing_loading', indices=[0], lower=0.)
comp.add_design_var('thrust_to_weight', indices=[0], lower=0.)
self.add_subsystem('inputs_comp', comp, promotes=['*'])
#
comp = PowerCombinationComp(
shape=shape,
out_name='wing_loading_lbf_ft2',
powers_dict=dict(wing_loading=1., ),
coeff=units('lbf/ft^2', 'N/m^2'),
)
self.add_subsystem('wing_loading_lbf_ft2_comp', comp, promotes=['*'])
comp = PowerCombinationComp(
shape=shape,
out_name='ref_power_to_weight',
powers_dict=dict(
ref_thrust_to_weight=1.,
cruise_speed=1.,
propulsive_efficiency=-1.,
),
)
self.add_subsystem('ref_power_to_weight_comp', comp, promotes=['*'])
comp = PowerCombinationComp(
shape=shape,
out_name='power_to_weight',
powers_dict=dict(
thrust_to_weight=1.,
cruise_speed=1.,
propulsive_efficiency=-1.,
),
)
self.add_subsystem('power_to_weight_comp', comp, promotes=['*'])
comp = PowerCombinationComp(
shape=shape,
out_name='wing_area',
powers_dict=dict(
gross_weight=1.,
wing_loading=-1.,
),
)
self.add_subsystem('wing_area_comp', comp, promotes=['*'])
comp = PowerCombinationComp(
shape=shape,
out_name='max_thrust',
powers_dict=dict(
gross_weight=1.,
thrust_to_weight=1.,
),
)
self.add_subsystem('max_thrust_comp', comp, promotes=['*'])
#
comp = StallWingLoadingComp(shape=shape)
self.add_subsystem('stall_wing_loading_comp', comp, promotes=['*'])
comp = ClimbThrustToWeightComp(shape=shape)
self.add_subsystem('climb_thrust_to_weight_comp', comp, promotes=['*'])
comp = TurnThrustToWeightComp(shape=shape)
self.add_subsystem('turn_thrust_to_weight_comp', comp, promotes=['*'])
if aircraft['thrust_source_type'] == 'jet':
TakeoffWingLoadingComp = JetTakeoffWingLoadingComp
elif aircraft['thrust_source_type'] == 'propeller':
TakeoffWingLoadingComp = PropellerTakeoffWingLoadingComp
else:
raise Exception()
comp = TakeoffWingLoadingComp(shape=shape)
self.add_subsystem('takeoff_wing_loading_comp', comp, promotes=['*'])
comp = LandingWingLoadingComp(shape=shape)
self.add_subsystem('landing_wing_loading_comp', comp, promotes=['*'])
#
for con_name in [
'stall',
'takeoff',
'landing',
]:
comp = LinearCombinationComp(
shape=shape,
out_name='{}_wing_loading_constraint'.format(con_name),
coeffs_dict={
'wing_loading': 1.,
'{}_wing_loading'.format(con_name): -1.,
},
)
comp.add_constraint('{}_wing_loading_constraint'.format(con_name),
indices=[0],
upper=0.)
self.add_subsystem(
'{}_wing_loading_constraint_comp'.format(con_name),
comp,
promotes=['*'])
for con_name in [
'climb',
'turn',
]:
comp = LinearCombinationComp(
shape=shape,
out_name='{}_thrust_to_weight_constraint'.format(con_name),
coeffs_dict={
'thrust_to_weight': -1.,
'{}_thrust_to_weight'.format(con_name): 1.,
},
)
comp.add_constraint(
'{}_thrust_to_weight_constraint'.format(con_name),
indices=[0],
upper=0.)
self.add_subsystem(
'{}_thrust_to_weight_constraint_comp'.format(con_name),
comp,
promotes=['*'])
comp = PowerCombinationComp(
shape=shape,
out_name='{}_power_to_weight'.format(con_name),
powers_dict={
'{}_thrust_to_weight'.format(con_name): 1.,
'cruise_speed': 1.,
'propulsive_efficiency': -1.,
},
)
self.add_subsystem('{}_power_to_weight_comp'.format(con_name),
comp,
promotes=['*'])
a = 0.5
comp = LinearPowerCombinationComp(
shape=shape,
out_name='sizing_performance_objective',
terms_list=[
(1 - a, dict(
thrust_to_weight=1.,
ref_thrust_to_weight=-1.,
)),
(-a, dict(
wing_loading=1.,
ref_wing_loading=-1.,
)),
],
)
self.add_subsystem(
'sizing_performance_objective_comp'.format(con_name),
comp,
promotes=['*'])
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)
def setup(self):
fe_model = self.options['fe_model']
nelx = self.options['num_ele_x']
nely = self.options['num_ele_y']
penal = self.options['penal_factor']
volume_fraction = self.options['volume_fraction']
radius = self.options['filter_radius']
# Check FEA assembly and evaluate dimensions of the sparse matrix
n_elements = nelx * nely
n_dof = 2 * (nelx + 1) * (nely + 1)
k_vals = fe_model.k_val #assemble_K(np.ones(n_elements)).flatten()
sK_size = len(k_vals) # Sparse arrays length under BC.
unknown_dof = fe_model.unknown_dof
n_eigenvalues = 1
# Setup design variables ['densities']
comp = IndepVarComp()
comp.add_output('densities', val=1.0, shape=n_elements)
comp.add_design_var('densities', lower=0.01, upper=1.0)
self.add_subsystem('input_comp', comp)
# With Filter
self.connect('input_comp.densities', 'filter_comp.densities')
# No Filter
# self.connect('input_comp.densities',
# 'volume_comp.densities')
# Density Filter
comp = DensityFilterComp(num_ele_x=nelx, num_ele_y=nely, radius=radius)
self.add_subsystem('filter_comp', comp)
self.connect('filter_comp.densities_f', 'penalization_comp.densities')
self.connect('filter_comp.densities_f', 'volume_comp.densities')
# Penalization
comp = PenalizationComp(penal=penal, n_elements=n_elements)
self.add_subsystem('penalization_comp', comp)
self.connect('penalization_comp.multipliers',
'stiffness_matrix_comp.multipliers')
# Stiffness Matrix
comp = StiffnessMatrixComp(fe_model=fe_model,
n_elements=n_elements,
n_dof=n_dof,
sK_size=sK_size)
self.add_subsystem('stiffness_matrix_comp', comp)
self.connect('stiffness_matrix_comp.stiffness_matrix',
'elasticity_comp.stiffness_matrix')
self.connect('stiffness_matrix_comp.stiffness_matrix',
'stability_comp.stiffness_matrix')
# Elasticity
comp = ElasticityComp(fe_model=fe_model,
n_dof=n_dof,
sK_size=sK_size,
unknown_dof=unknown_dof)
self.add_subsystem('elasticity_comp', comp)
self.connect('elasticity_comp.displacements',
'compliance_comp.displacements')
self.connect('elasticity_comp.displacements',
'geometric_matrix_comp.displacements')
# Geometric Stiffness Matrix
comp = GeometricMatrixComp(fe_model=fe_model,
n_dof=n_dof,
unknown_dof=unknown_dof)
self.add_subsystem('geometric_matrix_comp', comp)
self.connect('geometric_matrix_comp.geometric_matrix',
'stability_comp.geometric_matrix')
# Stability
comp = StabilityComp(fe_model=fe_model,
n_dof=n_dof,
sK_size=sK_size,
unknown_dof=unknown_dof,
n_eigenvalues=n_eigenvalues)
self.add_subsystem('stability_comp', comp)
# # Compliance
comp = ComplianceComp(fe_model=fe_model,
ndof=n_dof,
unknown_dof=unknown_dof)
self.add_subsystem('compliance_comp', comp)
# Volume
comp = VolumeComp(nelements=n_elements)
self.add_subsystem('volume_comp', comp)
# Stablity constraint / aggregation function
# Design variables
self.add_design_var('input_comp.densities', lower=1e-2, upper=1)
# Objective
self.add_objective('compliance_comp.compliance')
# Constraints:
self.add_constraint('volume_comp.volume',
upper=volume_fraction,
linear=True)
self.add_constraint('stability_comp.critical_loads', upper=51)
import numpy as np
from openmdao.api import Problem, Group, IndepVarComp, ExecComp, ScipyOptimizeDriver
from lsdo_aircraft.api import Atmosphere
from lift_comp import liftComp
prob = Problem()
model = Group()
comp = IndepVarComp()
comp.add_output('speed', val=250)
comp.add_output('density', val=1.225)
comp.add_output('Cl', val=1.0)
comp.add_design_var('density', upper=0.0)
model.add_subsystem('inputs_comp', comp, promotes=['*'])
# atmosphere_group = Atmosphere()
# # model.add_subsystem('atmosphere_group', atmosphere_group)
# model.add_subsystem('atmosphere_group', subsys=Atmosphere())
comp = liftComp()
model.add_subsystem('lift', comp, promotes=['*'])
comp = ExecComp('Weight = lift')
comp.add_objective('Weight', scaler=120000.) #weight in kg
model.add_subsystem('vertEqui_comp', comp, promotes=['*'])
def setup(self):
fem_solver = self.options['fem_solver']
length_x = self.options['length_x']
length_y = self.options['length_y']
num_nodes_x = self.options['num_nodes_x']
num_nodes_y = self.options['num_nodes_y']
forces = self.options['forces']
p = self.options['p']
w = self.options['w']
nodes = self.options['nodes']
volume_fraction = self.options['volume_fraction']
num = num_nodes_x * num_nodes_y
num_el = (num_nodes_x - 1) * (num_nodes_y - 1)
state_size = 2 * num_nodes_x * num_nodes_y + 2 * num_nodes_y
disp_size = 2 * num_nodes_x * num_nodes_y
rhs = np.zeros(state_size)
rhs[:disp_size] = forces
# inputs
comp = IndepVarComp()
comp.add_output('rhs', val=rhs)
comp.add_output('forces', val=forces)
comp.add_output('dvs', val=0.5, shape=num_el)
comp.add_design_var('dvs', lower=0.01, upper=1.0)
# comp.add_design_var('x', lower=-4, upper=4)
self.add_subsystem('inputs_comp', comp)
self.connect('inputs_comp.dvs', 'penalization_comp.x')
self.connect('inputs_comp.dvs', 'weight_comp.x')
# penalization
comp = PenalizationComp(num=num_el, p=p)
self.add_subsystem('penalization_comp', comp)
self.connect('penalization_comp.y', 'states_comp.multipliers')
# states
comp = StatesComp(fem_solver=fem_solver,
num_nodes_x=num_nodes_x,
num_nodes_y=num_nodes_y,
nodes=nodes,
isNodal=False)
self.add_subsystem('states_comp', comp)
self.connect('inputs_comp.rhs', 'states_comp.rhs')
# disp
comp = DispComp(num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y)
self.add_subsystem('disp_comp', comp)
self.connect('states_comp.states', 'disp_comp.states')
# compliance
comp = ComplianceComp(num_nodes_x=num_nodes_x, num_nodes_y=num_nodes_y)
self.add_subsystem('compliance_comp', comp)
self.connect('disp_comp.disp', 'compliance_comp.disp')
self.connect('inputs_comp.forces', 'compliance_comp.forces')
# weight
comp = WeightComp(num=num_el)
comp.add_constraint('weight', upper=volume_fraction)
self.add_subsystem('weight_comp', comp)
# objective
comp = ObjectiveComp(w=w)
comp.add_objective('objective')
self.add_subsystem('objective_comp', comp)
self.connect('compliance_comp.compliance', 'objective_comp.compliance')
self.connect('weight_comp.weight', 'objective_comp.weight')
group = Group()
ivc = IndepVarComp()
ivc.add_output('V0', val=3.)
ivc.add_output('theta', val=0.)
group.add_subsystem('ivc', ivc, promotes=['*'])
t_comp = ExecComp('t = 2 * V0 * sin(theta) / 9.81')
group.add_subsystem('t_comp', t_comp, promotes=['*'])
dx_comp = ExecComp('dx = V0 * cos(theta) * t')
group.add_subsystem('dx_comp', dx_comp, promotes=['*'])
prob.model = group
# Define the optimization problem
ivc.add_design_var('theta', lower=0., upper=90. * np.pi / 180.)
dx_comp.add_objective('dx', scaler=-1.)
# set the optimization algorithm
prob.driver = ScipyOptimizeDriver() # 'includes the driver into the model'
prob.setup() # 'this initializes the setup of the problem
prob.run_driver() # ' this runs the driver(the optimizer) for the model
prob.run_model() # this runs the model
prob.check_partials(compact_print=True)
prob.model.list_outputs()
