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()