def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- # [ tag , initial, (lb,ub) , scaling , units ] problem.inputs = np.array([ [ 'wing_area' , 95 , ( 90. , 130. ) , 100. , Units.meter**2], [ 'cruise_altitude' , 11 , ( 9 , 14. ) , 10. , Units.km], ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([ [ 'fuel_burn', 10000, Units.kg ] ]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] problem.constraints = np.array([ [ 'design_range_fuel_margin' , '>', 0., 1E-1, Units.less], #fuel margin defined here as fuel ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ [ 'wing_area' , ['vehicle_configurations.*.wings.main_wing.areas.reference', 'vehicle_configurations.*.reference_area' ]], [ 'cruise_altitude' , 'missions.base.segments.climb_5.altitude_end' ], [ 'fuel_burn' , 'summary.base_mission_fuelburn' ], [ 'design_range_fuel_margin' , 'summary.max_zero_fuel_margin' ], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Missions.setup(nexus.analyses) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() nexus.total_number_of_iterations = 0 return nexus
def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- # [ tag , initial, (lb,ub) , scaling , units ] problem.inputs = np.array([ ['wing_area', 72.72, (65.0, 85.0), 100., Units.meter**2], ['aspect_ratio', 8.6, (7.6, 10.6), 100.0, Units.less], # ['taper_ratio', 0.3275, (0.2875, 0.4275), 1., Units.less], ['t_c_ratio', 0.11, (0.09, 0.15), 1., Units.less], ['sweep_angle', 23., (18.0, 35.0), 100.0, Units.deg], ['cruise_range', 1109.0, (800., 1350.), 10000.0, Units.nautical_miles], ['beta', 1., (1., 1.), 1., Units.less], ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([ # ['fuel_burn', 10000., Units.kg], ['objective', 10000., Units.kg], ]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] # CONSTRAINTS ARE SET TO BE BIGGER THAN ZERO, SEE PROCEDURE (SciPy's SLSQP optimization algorithm assumes this form) problem.constraints = np.array([ # ['design_range_margin', '=', 0., 100., Units.nautical_miles], # Range consistency ['fuel_margin', '>', 0., 1000., Units.kg], #fuel margin defined here as fuel ['Throttle_min', '>', 0., 1., Units.less], ['Throttle_max', '>', 0., 1., Units.less], ['tofl_mtow_margin', '>', 0., 100., Units.m], # take-off field length ['mzfw_consistency', '>', 0., 1000., Units.kg], # MZFW consistency ['design_range_ub', '>', 0., 1., Units.nautical_miles], # Range consistency ['design_range_lb', '>', 0., 1., Units.nautical_miles], # Range consistency ['time_to_climb', '>', 0., 10., Units.min], # Time to climb consistency ['climb_gradient', '>', 0., 1., Units.less], # second segment climb gradient ['lfl_mlw_margin', '>', 0., 100., Units.m], # landing field length ['max_fuel_margin', '>', 0., 1000., Units.kg], # max fuel margin # ['range_HH_margin', '>', 0., 1000., Units.nautical_miles], # Range for Hot and High ['TOW_HH_margin', '>', 0., 1000., Units.kg], # TOW for Hot and High # ['MTOW', '>', 0., 100000., Units.kg], # TOW for Hot and High # ['BOW', '>', 0., 1., Units.kg], # TOW for Hot and High ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ [ 'wing_area', [ 'vehicle_configurations.*.wings.main_wing.areas.reference', 'vehicle_configurations.*.reference_area' ] ], [ 'aspect_ratio', 'vehicle_configurations.*.wings.main_wing.aspect_ratio' ], # ['taper_ratio', 'vehicle_configurations.*.wings.main_wing.taper' ], [ 't_c_ratio', 'vehicle_configurations.*.wings.main_wing.thickness_to_chord' ], [ 'sweep_angle', 'vehicle_configurations.*.wings.main_wing.sweeps.quarter_chord' ], ['cruise_range', 'missions.base.segments.cruise.distance'], # ['fuel_burn', 'summary.base_mission_fuelburn' ], ['fuel_margin', 'summary.fuel_margin'], ['Throttle_min', 'summary.throttle_min'], ['Throttle_max', 'summary.throttle_max'], ['tofl_mtow_margin', 'summary.takeoff_field_length_margin'], ['mzfw_consistency', 'summary.mzfw_consistency'], # ['design_range_margin', 'summary.design_range_margin'], ['design_range_ub', 'summary.design_range_ub'], ['design_range_lb', 'summary.design_range_lb'], ['time_to_climb', 'summary.time_to_climb'], ['climb_gradient', 'summary.climb_gradient'], ['lfl_mlw_margin', 'summary.lfl_mlw_margin'], ['max_fuel_margin', 'summary.max_fuel_margin'], # ['range_HH_margin', 'summary.range_HH_margin'], ['TOW_HH_margin', 'summary.TOW_HH_margin'], # ['MTOW', 'summary.MTOW'], # ['BOW', 'summary.BOW'], ['beta', 'vehicle_configurations.base.wings.main_wing.beta'], ['objective', 'summary.objective'], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Missions.setup(nexus.analyses) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() nexus.total_number_of_iterations = 0 return nexus
def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- # [ tag , initial, (lb,ub) , scaling , units ] problem.inputs = np.array([ #[ 'wing_span' , 9.4 , ( 8.0 , 15. ) , 9.4 , Units.meter], #[ 'wing_root_chord' , 2.0 , ( 1. , 4. ) , 2.0 , Units.meter], #[ 'wing_thickness_to_chord' , 0.15 , ( 0.1 , 0.5 ) , 0.15 , Units.less], #[ 'wing_taper_ratio' , 0.9 , ( 0.55 , 1.0 ) , 0.9 , Units.less], #[ 'cruise_distance' , 150. , ( 50. , 1000. ) , 150. , Units.nautical_miles], #[ 'cruise_airspeed' , 200. , ( 90. , 300. ) , 200. , Units['m/s']], #[ 'climb1_airspeed' , 125.0 , ( 50.0 , 250.0 ) , 125.0 , Units['m/s']], #[ 'climb2_airspeed' , 190.0 , ( 70.0 , 270.0 ) , 190.0 , Units['m/s']], #[ 'descent1_airspeed' , 180.0 , ( 100. , 270. ) , 180.0 , Units['m/s']], #[ 'descent2_airspeed' , 145.0 , ( 50. , 200.0 ) , 145.0 , Units['m/s']], #[ 'climb1_altitude' , 3. , ( 1. , 5. ) , 3. , Units.km], #[ 'climb2_altitude' , 8.0 , ( 7. , 15. ) , 8.0 , Units.km], #[ 'descent1_altitude' , 3.0 , ( 2. , 7. ) , 3.0 , Units.km], #[ 'climb1_rate' , 6.0 , ( 3. , 17. ) , 6.0 , Units['m/s']], #[ 'climb2_rate' , 3.0 , ( 2. , 12. ) , 3.0 , Units['m/s']], #[ 'descent1_rate' , 4.5 , ( 3. , 15. ) , 4.5 , Units['m/s']], #[ 'descent2_rate' , 3.0 , ( 2. , 12. ) , 3.0 , Units['m/s']], ['voltage', 470., (30., 10000.), 470., Units['volt']], ['motor_kv_cruise', 181., (10., 500.), 181., Units['rpm/volt']], ['motor_kv_HL', 91., (5., 300.), 91., Units['rpm/volt']], ['bat_spec_energy', 6.1, (3., 10000.), 6.1, Units.Wh / Units.kg], ['bat_spec_power', 0.833, (0.5, 10000.), 0.833, Units.kW / Units.kg], ['bat_max_voltage', 60.1, (0.5, 100000.), 60.1, Units['volt']], ['bat_resistance', 0.0151, (0.0001, 100.), 0.0151, Units['ohm']], ['payload_draw', 50.1, (5., 100.), 50.1, Units.watts], ['avionics_draw', 50.1, (5., 100.), 50.1, Units.watts], ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([ #[ 'range', -540.9079921321364, Units.nautical_miles ], ['battery_energy_max', 8476560.0, Units.Wh], ]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] problem.constraints = np.array([ #[ 'energy_constraint', '=', 0.0, 1.0, Units.less], ['battery_energy_min', '>', -0.01, 100000.0, Units.Wh], #[ 'battery_draw' , '>', -0.1, 1.0, Units.kW ], #[ 'CL' , '>', 0.0, 1.0, Units.less], ['Throttle_cruise', '>', -0.1, 1.0, Units.less], ['Throttle_HL', '>', -0.1, 1.0, Units.less], ['Throttle_cruise', '<', 1.5, 1.0, Units.less], ['Throttle_HL', '<', 1.5, 1.0, Units.less], ['HL_rpm_min', '>', -0.1, 1.0, Units['rpm']], ['HL_rpm_max', '<', 70000, 1.0, Units['rpm']], ['cruise_rpm_min', '>', -0.1, 1.0, Units['rpm']], ['cruise_rpm_max', '<', 100000, 1.0, Units['rpm']], #[ 'lift_coefficient' , '>', -0.1, 1.0, Units.less], ['mach_number', '<', 1.5, 1.0, Units.less], ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ #[ 'wing_span' , 'vehicle_configurations.*.wings.main_wing.spans.projected'], #[ 'wing_root_chord' , 'vehicle_configurations.*.wings.main_wing.chords.root' ], #[ 'wing_thickness_to_chord' , 'vehicle_configurations.*.wings.main_wing.thickness_to_chord' ], #[ 'wing_taper_ratio' , 'vehicle_configurations.*.wings.main_wing.taper' ], #[ 'cruise_distance' , 'missions.mission.segments.cruise.distance' ], #[ 'cruise_airspeed' , 'missions.mission.segments.cruise.air_speed' ], #[ 'climb1_airspeed' , 'missions.mission.segments.climb_1.air_speed' ], #[ 'climb2_airspeed' , 'missions.mission.segments.climb_2.air_speed' ], #[ 'descent1_airspeed' , 'missions.mission.segments.descent_1.air_speed' ], #[ 'descent2_airspeed' , 'missions.mission.segments.descent_2.air_speed' ], #[ 'climb1_altitude' , 'missions.mission.segments.climb_1.altitude_end' ], #[ 'climb2_altitude' , 'missions.mission.segments.climb_2.altitude_end' ], #[ 'descent1_altitude' , 'missions.mission.segments.descent_1.altitude_end' ], #[ 'climb1_rate' , 'missions.mission.segments.climb_1.climb_rate' ], #[ 'climb2_rate' , 'missions.mission.segments.climb_2.climb_rate' ], #[ 'descent1_rate' , 'missions.mission.segments.descent_1.descent_rate' ], #[ 'descent2_rate' , 'missions.mission.segments.descent_2.descent_rate' ], ['voltage', 'vehicle_configurations.*.propulsors.propulsor.voltage'], [ 'motor_kv_cruise', 'vehicle_configurations.*.propulsors.propulsor.motor_forward.speed_constant' ], [ 'motor_kv_HL', 'vehicle_configurations.*.propulsors.propulsor.motor_lift.speed_constant' ], [ 'bat_spec_energy', 'vehicle_configurations.*.propulsors.propulsor.battery.specific_energy' ], [ 'bat_spec_power', 'vehicle_configurations.*.propulsors.propulsor.battery.specific_power' ], [ 'bat_max_voltage', 'vehicle_configurations.*.propulsors.propulsor.battery.max_voltage' ], [ 'bat_resistance', 'vehicle_configurations.*.propulsors.propulsor.battery.resistance' ], [ 'payload_draw', 'vehicle_configurations.*.propulsors.propulsor.payload.power_draw' ], [ 'avionics_draw', 'vehicle_configurations.*.propulsors.propulsor.avionics.power_draw' ], #[ 'range' , 'summary.total_range' ], #[ 'max_lift' , 'summary.max_lift_coefficient_all_segments' ], ['battery_energy_max', 'summary.max_battery_energy_all_segments'], ['battery_energy_min', 'summary.min_battery_energy_all_segments'], ['battery_draw', 'summary.battery_charging_power_all_segments'], ['Throttle_cruise', 'summary.throttle_all_segments'], ['Throttle_HL', 'summary.lift_throttle_all_segments'], ['HL_rpm_min', 'summary.min_rpm_lift_all_segments'], ['HL_rpm_max', 'summary.max_rpm_lift_all_segments'], ['cruise_rpm_min', 'summary.min_rpm_forward_all_segments'], ['cruise_rpm_max', 'summary.max_rpm_forward_all_segments'], ['lift_coefficient', 'summary.lift_coefficient_all_segments'], ['mach_number', 'summary.mach_number_all_segments'], ['AoA_min', 'summary.min_aoa_all_segments'], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Missions.setup(nexus.analyses, nexus.vehicle_configurations) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- #nexus.summary = Data() nexus.total_number_of_iterations = 0 return nexus
def setup(solver_name): nexus = Nexus() problem = Data() nexus.optimization_problem = problem nexus.solver_name = solver_name # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- problem.inputs = np.array([ # [ tag , initial,( lb , ub ) , scaling , units ] ['x1', 1., (-2., 2.), 1., Units.less], ['x2', 1., (-2., 2.), 1., Units.less], ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([['y', 1., Units.less]]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] problem.constraints = np.array([ ['x1', '>', -10., 1., Units.less], ['x2', '>', -50., 1., Units.less], ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] # don't set wing_area for initial configuration so that values can be used later problem.aliases = [ ['x1', 'vehicle_configurations.base.x1'], ['x2', 'vehicle_configurations.base.x2'], ['y', 'obj'], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = vehicle_opt_pack.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = None # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = None # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = procedure_opt_pack.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() nexus.total_number_of_iterations = 0 return nexus
def main(): seed = np.random.seed(1) # ------------------------------------------------------------------ # SLSQP # ------------------------------------------------------------------ solver_name = 'SLSQP' problem = setup(solver_name) problem.optimization_problem.constraints = np.array([ ['x1', '>', -10., 1., Units.less], ['x1', '=', 0., 1., Units.less], ['x2', '>', 1., 1., Units.less], ['x2', '<', 2., 1., Units.less], ]) print('\n\n Checking basic additive with one active constraint...') # suppress iteration printout Nexus.translate(problem) sys.stdout = open(os.devnull, 'w') outputs = scipy_setup.SciPy_Solve(problem, solver='SLSQP', sense_step=1.4901161193847656e-08, pop_size=10, prob_seed=seed) # end suppression of interation printout sys.stdout = sys.__stdout__ print(outputs) obj = scipy_setup.SciPy_Problem(problem, outputs)[0] x1 = outputs[0] x2 = outputs[1] # Check Results assert (np.isclose(obj, 1, atol=1e-6)) assert (np.isclose(x1, 0, atol=1e-2)) assert (np.isclose(x2, 1, atol=1e-2)) # test writing output function filename = 'optimization_output.txt' write_optimization_outputs(problem, filename) os.remove('optimization_output.txt') # ------------------------------------------------------------------ # Differential Evolution # ------------------------------------------------------------------ print('\n\n Checking differential evolution algorithm') solver_name = 'differential_evolution' problem = setup(solver_name) problem.optimization_problem.constraints = np.array([ ['x1', '>', -10., 1., Units.less], ['x1', '=', 0., 1., Units.less], ['x2', '>', 1., 1., Units.less], ['x2', '<', 2., 1., Units.less], ]) # suppress iteration printout sys.stdout = open(os.devnull, 'w') outputs = scipy_setup.SciPy_Solve(problem, solver='differential_evolution', sense_step=1.4901161193847656e-08, pop_size=10, prob_seed=seed) # end suppression of interation printout sys.stdout = sys.__stdout__ print(outputs) obj = outputs.fun x1 = outputs.x[0] x2 = outputs.x[1] # Check Results assert (np.isclose(obj, 1, atol=1e-5)) assert (np.isclose(x1, 0, atol=1e-4)) assert (np.isclose(x2, 1, atol=1e-4)) # ------------------------------------------------------------------ # Particle Swarm Optimization # ------------------------------------------------------------------ solver_name = 'particle_swarm_optimization' problem = setup(solver_name) problem.optimization_problem.constraints = np.array([ ['x1', '>', -10., 1., Units.less], ['x2', '>', 1., 1., Units.less], ['x2', '<', 2., 1., Units.less], ]) print('\n\n Checking particle swarm optimization algorithm') # suppress iteration printout sys.stdout = open(os.devnull, 'w') outputs = scipy_setup.SciPy_Solve(problem, solver='particle_swarm_optimization', sense_step=1.4901161193847656e-08, pop_size=100, prob_seed=seed) # end suppression of interation printout sys.stdout = sys.__stdout__ print(outputs) obj = outputs[1][0] x1 = outputs[0][0] x2 = outputs[0][1] # Check Results assert (np.isclose(obj, 1, atol=1e-2)) assert (np.isclose(x1, 0, atol=1e-1)) assert (np.isclose(x2, 1, atol=1e-1)) return
def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- # [ tag , initial, (lb,ub) , scaling , units ] problem.inputs = np.array([ ['wing_aspect_ratio', 2.7935, (1., 7.), 2.7935, Units.less], ['wing_area', 68.172, (50., 80.), 68.172, Units.meter**2], ['cruise_airspeed', 450., (40., 120.), 70., Units.knots], ['climb1_airspeed', 268.25, (100.0, 200.0), 268.25, Units.knots], ['climb2_airspeed', 326.56, (300.0, 400.0), 326.56, Units.knots], ['descent1_airspeed', 440.0, (400.0, 500.0), 440.0, Units.knots], ['descent2_airspeed', 250.0, (200.0, 300.0), 250.0, Units.knots], ['climb1_altitude', 3., (1., 5.), 3., Units.km], ['climb2_altitude', 11.28, (7., 15.), 11.28, Units.km], ['descent1_altitude', 3.657, (2., 7.), 3.657, Units.km], ['climb1_rate', 15.24, (5., 20.), 15.24, Units['m/s']], ['climb2_rate', 9.14, (3., 10.), 9.14, Units['m/s']], ['descent1_rate', 11.68, (3., 15.), 11.68, Units['m/s']], ['descent2_rate', 7.62, (2., 10.), 7.62, Units['m/s']], ['voltage', 461., (100., 700.), 461., Units.watts], ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([['range', -10, Units.nautical_miles]]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] problem.constraints = np.array([ #[ 'energy_constraint', '=', 0.0, 1.0, Units.less], ['battery_mass', '>', 0.0, 1.0, Units.kg], #[ 'CL' , '>', 0.0, 1.0, Units.less], ['Throttle_min', '>', 0.0, 1.0, Units.less], ['Throttle_max', '>', 0.0, 1.0, Units.less], ['HL_rpm', '>=', 0.0, 100, Units['rpm']], ['cruise_rpm', '>=', 0.0, 100, Units['rpm']], ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ [ 'wing_aspect_ratio', 'vehicle_configurations.*.wings.main_wing.aspect_ratio' ], [ 'wing_area', 'vehicle_configurations.*.wings.main_wing.areas.reference' ], ['cruise_airspeed', 'missions.mission.segments.cruise.air_speed'], ['climb1_airspeed', 'missions.mission.segments.climb_1.air_speed'], ['climb2_airspeed', 'missions.mission.segments.climb_2.air_speed'], ['descent1_airspeed', 'missions.mission.segments.descent_1.air_speed'], ['descent2_airspeed', 'missions.mission.segments.descent_2.air_speed'], ['climb1_altitude', 'missions.mission.segments.climb_1.altitude_end'], ['climb2_altitude', 'missions.mission.segments.climb_2.altitude_end'], [ 'descent1_altitude', 'missions.mission.segments.descent_1.altitude_end' ], ['climb1_rate', 'missions.mission.segments.climb_1.climb_rate'], ['climb2_rate', 'missions.mission.segments.climb_2.climb_rate'], ['descent1_rate', 'missions.mission.segments.descent_1.descent_rate'], ['descent2_rate', 'missions.mission.segments.descent_2.descent_rate'], ['voltage', 'vehicle_configurations.*.propulsors.propulsor.voltage'], ['range', 'nexus.missions.mission.total_range'], [ 'battery_mass', 'vehicle_configurations.base.propulsors.network.battery.mass_properties.mass' ], ['Throttle_min', 'summary.throttle_min'], ['Throttle_max', 'summary.throttle_max'], ['HL_rpm', 'state.conditions.propulsion.rpm_lift'], ['cruise_rpm', 'state.conditions.propulsion.rpm_forward'], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Missions.setup(nexus.analyses, nexus.vehicle_configurations) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() nexus.total_number_of_iterations = 0 return nexus
def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- problem.inputs = np.array([ # Variable inputs ['wing_area', 700., (650., 725.), 500., Units.meter**2], ['MTOW', 207e3, (207e3, 207e3), 200e3, Units.kg], ['alt_outgoing_cruise', 13.14, (9., 14.), 13., Units.km], # 13.15 #explain the physics behing the optimizer ['design_thrust', 110e3, (100e3, 120e3), 100e3, Units.N], ['outgoing_cruise_speed', 190., (180., 212.), 200., Units['m/s']], # 191 ['spray_cruise_speed', 210., (205., 212.), 200, Units['m/s']], ['cruise1_distance', 1050., (1000., 1200.), 1075., Units.km], ['cruise2_distance', 1173., (1000., 1300.), 1225., Units.km], ['cruise3_distance', 1001., (900., 1200.), 1000., Units.km], ['cruise_outgoing_distance', 3393., (3200., 3500.), 3300., Units.km], # climb throttle as input? # "Set" inputs ['AR', 13., (12., 14.), 13., Units.less], # aerosol released per kg of fuel ratio max? ['payload', 35e3, (35e3, 35e3), 30e3, Units.kg], # speeds??? ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([['fuel_burn', 60000., Units.kg]]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] problem.constraints = np.array([ # ['min_throttle', '>', 0., 1e-1, Units.less], ['max_throttle', '<', 1., 1., Units.less], # ['main_mission_time', '<', 11.1, 10, Units.h], ['design_range_fuel_margin', '>', 0.1, 1E-1, Units.less], # ['take_off_field_length', '<', 2500., 2500, Units.m], # ['landing_field_length', '<', 2500., 2500, Units.m], ['clmax', '<', 1.1, 1, Units.less], ['non_spraying_range', '>', 3500., 3500., Units.km], ['spraying_range', '>', 3500., 3500., Units.km] # main mission range ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ [ 'wing_area', [ 'vehicle_configurations.*.wings.main_wing.areas.reference', 'vehicle_configurations.*.reference_area' ] ], [ 'MTOW', [ 'vehicle_configurations.*.mass_properties.takeoff', "vehicle_configurations.*.mass_properties.max_takeoff" ] ], [ 'alt_outgoing_cruise', 'missions.base.segments.final_outgoing.altitude_end' ], [ 'design_thrust', 'vehicle_configurations.*.propulsors.turbofan.thrust.total_design' ], [ 'spray_cruise_speed', [ 'missions.base.segments.cruise_1.air_speed', 'missions.base.segments.cruise_2.air_speed', 'missions.base.segments.cruise_final.air_speed' ] ], [ 'outgoing_cruise_speed', 'missions.base.segments.cruise_outgoing.air_speed' ], ['AR', 'vehicle_configurations.*.wings.main_wing.aspect_ratio'], [ 'payload', [ 'vehicle_configurations.*.mass_properties.max_payload', 'vehicle_configurations.*.mass_properties.payload' ] ], ['fuel_burn', 'summary.base_mission_fuelburn'], ['min_throttle', 'summary.min_throttle'], ['max_throttle', 'summary.max_throttle'], ['main_mission_time', 'summary.main_mission_time'], ['mission_range', 'summary.mission_range'], ['clmax', 'summary.clmax'], ['design_range_fuel_margin', 'summary.max_zero_fuel_margin'], ['take_off_field_length', 'summary.field_length_takeoff'], ['landing_field_length', 'summary.field_length_landing'], ['MTOW_delta', 'summary.MTOW_delta'], ['cruise_speed', 'missions.base.segments.cruise_empty.air_speed'], ['cruise1_distance', 'missions.base.segments.cruise_1.distance'], ['cruise2_distance', 'missions.base.segments.cruise_2.distance'], ['cruise3_distance', 'missions.base.segments.cruise_final.distance'], [ 'cruise_outgoing_distance', 'missions.base.segments.cruise_outgoing.distance' ], ['non_spraying_range', 'summary.empty_range'], ['spraying_range', 'summary.spray_range'], # [ # "missions.base.segments.cruise_highlift.air_speed", # # "missions.base.segments.cruise_2.air_speed"]], # ['return_cruise_speed', "missions.base.segments.cruise_final.air_speed"], ['oswald', 'vehicle_configurations.*.wings.main_wing.span_efficiency'], ['cruise_altitude', "missions.base.segments.climb_8.altitude_end"], ['return_cruise_alt', 'missions.base.segments.descent_1.altitude_end'], [ 'bypass', 'vehicle_configurations.*.propulsors.turbofan.bypass_ratio' ], ['wing_sweep', 'vehicle_configurations.*.wings.main_wing.sweep'], ['oew', 'summary.op_empty'], ['Nothing', 'summary.nothing'], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Mission.setup(nexus.analyses) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() return nexus
def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- # [ tag , initial, (lb,ub) , scaling , units ] problem.inputs = np.array([ ['wing_area', 72.72, (72.72, 72.72), 100., Units.meter**2], ['aspect_ratio', 8.6, (8.6, 8.6), 10.0, Units.less], ['taper_ratio', 0.3275, (0.3275, 0.3275), 1., Units.less], ['t_c_ratio', 0.11, (0.11, 0.11), 1., Units.less], ['sweep_angle', 23.0, (23.0, 23.0), 100.0, Units.deg], ['cruise_range', 1088., (1000., 1200.), 10000.0, Units.nautical_miles], ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([ ['Nothing', 1., Units.kg], ]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] # CONSTRAINTS ARE SET TO BE BIGGER THAN ZERO, SEE PROCEDURE (SciPy's SLSQP optimization algorithm assumes this form) problem.constraints = np.array([ # ['design_range_fuel_margin', '>', 0., 1E-1, Units.less], #fuel margin defined here as fuel ['fuel_margin', '>', 0., 1000., Units.kg], # fuel tank volume capacity # ['CL', '>', 0, 1., Units.less], ['Throttle_min', '>', 0., 1., Units.less], ['Throttle_max', '>', 0., 1., Units.less], ['tofl_mtow_margin', '>', 0., 100., Units.m], # take-off field length ['mzfw_consistency', '>', 0., 1000., Units.kg], # MZFW consistency ['design_range_ub', '>', 0., 1., Units.nautical_miles], # Range consistency ['design_range_lb', '>', 0., 1., Units.nautical_miles], # Range consistency ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ ['wing_area', ['vehicle_configurations.*.wings.main_wing.areas.reference', 'vehicle_configurations.*.reference_area' ]], ['aspect_ratio', 'vehicle_configurations.*.wings.main_wing.aspect_ratio' ], ['taper_ratio', 'vehicle_configurations.*.wings.main_wing.taper' ], ['t_c_ratio', 'vehicle_configurations.*.wings.main_wing.thickness_to_chord' ], ['sweep_angle', 'vehicle_configurations.*.wings.main_wing.sweeps.quarter_chord'], ['cruise_range', 'missions.base.segments.cruise.distance' ], # ['fuel_burn', 'summary.base_mission_fuelburn' ], # ['design_range_fuel_margin', 'summary.max_zero_fuel_margin' ], ['fuel_margin', 'summary.fuel_margin' ], # ['CL', 'summary.CL'], ['Throttle_min', 'summary.throttle_min' ], ['Throttle_max', 'summary.throttle_max' ], ['Nothing', 'summary.nothing' ], ['tofl_mtow_margin', 'summary.takeoff_field_length_margin' ], ['mzfw_consistency', 'summary.mzfw_consistency' ], ['design_range_ub', 'summary.design_range_ub' ], ['design_range_lb', 'summary.design_range_lb' ], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Missions.setup(nexus.analyses) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() nexus.total_number_of_iterations = 0 return nexus
def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- problem.inputs = np.array([ # Variable inputs ['wing_area', 700., (650., 725.), 500., Units.meter ** 2], ['MTOW', 207e3, (207e3, 207e3), 200e3, Units.kg], ['alt_outgoing_cruise', 13.14, (9., 14.), 13., Units.km], # 13.15 #explain the physics behing the optimizer ['design_thrust', 110e3, (100e3, 120e3), 100e3, Units.N], ['outgoing_cruise_speed', 190., (180., 212.), 200., Units['m/s']], # 191 ['spray_cruise_speed', 210., (205., 212.), 200, Units['m/s']], ['cruise1_distance', 1050., (1000., 1200.), 1075., Units.km], ['cruise2_distance', 1173., (1000., 1300.), 1225., Units.km], ['cruise3_distance', 1001., (900., 1200.), 1000., Units.km], ['cruise_outgoing_distance', 3393., (3200., 3500.), 3300., Units.km], # climb throttle as input? # "Set" inputs ['AR', 13., (12., 14.), 13., Units.less], # aerosol released per kg of fuel ratio max? ['payload', 35e3, (35e3, 35e3), 30e3, Units.kg], # speeds??? ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([ ['fuel_burn', 60000., Units.kg] ]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] problem.constraints = np.array([ # ['min_throttle', '>', 0., 1e-1, Units.less], ['max_throttle', '<', 1., 1., Units.less], # ['main_mission_time', '<', 11.1, 10, Units.h], ['design_range_fuel_margin', '>', 0.1, 1E-1, Units.less], # ['take_off_field_length', '<', 2500., 2500, Units.m], # ['landing_field_length', '<', 2500., 2500, Units.m], ['clmax', '<', 1.1, 1, Units.less], ['non_spraying_range', '>', 3500., 3500., Units.km], ['spraying_range', '>', 3500., 3500., Units.km] # main mission range ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ ['wing_area', ['vehicle_configurations.*.wings.main_wing.areas.reference', 'vehicle_configurations.*.reference_area']], ['MTOW', ['vehicle_configurations.*.mass_properties.takeoff', "vehicle_configurations.*.mass_properties.max_takeoff"]], ['alt_outgoing_cruise', 'missions.base.segments.final_outgoing.altitude_end'], ['design_thrust', 'vehicle_configurations.*.propulsors.turbofan.thrust.total_design'], ['spray_cruise_speed', ['missions.base.segments.cruise_1.air_speed', 'missions.base.segments.cruise_2.air_speed', 'missions.base.segments.cruise_final.air_speed']], ['outgoing_cruise_speed', 'missions.base.segments.cruise_outgoing.air_speed'], ['AR', 'vehicle_configurations.*.wings.main_wing.aspect_ratio'], ['payload', ['vehicle_configurations.*.mass_properties.max_payload', 'vehicle_configurations.*.mass_properties.payload']], ['fuel_burn', 'summary.base_mission_fuelburn'], ['min_throttle', 'summary.min_throttle'], ['max_throttle', 'summary.max_throttle'], ['main_mission_time', 'summary.main_mission_time'], ['mission_range', 'summary.mission_range'], ['clmax', 'summary.clmax'], ['design_range_fuel_margin', 'summary.max_zero_fuel_margin'], ['take_off_field_length', 'summary.field_length_takeoff'], ['landing_field_length', 'summary.field_length_landing'], ['MTOW_delta', 'summary.MTOW_delta'], ['cruise_speed', 'missions.base.segments.cruise_empty.air_speed'], ['cruise1_distance', 'missions.base.segments.cruise_1.distance'], ['cruise2_distance', 'missions.base.segments.cruise_2.distance'], ['cruise3_distance', 'missions.base.segments.cruise_final.distance'], ['cruise_outgoing_distance', 'missions.base.segments.cruise_outgoing.distance'], ['non_spraying_range', 'summary.empty_range'], ['spraying_range', 'summary.spray_range'], # [ # "missions.base.segments.cruise_highlift.air_speed", # # "missions.base.segments.cruise_2.air_speed"]], # ['return_cruise_speed', "missions.base.segments.cruise_final.air_speed"], ['oswald', 'vehicle_configurations.*.wings.main_wing.span_efficiency'], ['cruise_altitude', "missions.base.segments.climb_8.altitude_end"], ['return_cruise_alt', 'missions.base.segments.descent_1.altitude_end'], ['bypass', 'vehicle_configurations.*.propulsors.turbofan.bypass_ratio'], ['wing_sweep', 'vehicle_configurations.*.wings.main_wing.sweep'], ['oew', 'summary.op_empty'], ['Nothing', 'summary.nothing'], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Mission.setup(nexus.analyses) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() return nexus
def setup(): nexus = Nexus() problem = Data() nexus.optimization_problem = problem # ------------------------------------------------------------------- # Inputs # ------------------------------------------------------------------- # [ tag , initial, (lb,ub) , scaling , units] problem.inputs = np.array([ ['wing_area', 61.10657012722955, (50.0, 72.0), 61., Units.meter**2], ['aspect_ratio', 12.088302121797874, (10., 14.), 12.0, Units.less], ['t_c_ratio', 0.15015861116831478, (0.11, 0.18), 0.15, Units.less], [ 'cruise_range', 331.5017418, (310., 350.), 331.3, Units.nautical_miles ], ['MTOW', 23029.880482, (21000., 25000.), 23000., Units.kg], ['MZFW_ratio', 0.912817661, (0.8, 0.98), 0.92, Units.less], ]) # ------------------------------------------------------------------- # Objective # ------------------------------------------------------------------- # throw an error if the user isn't specific about wildcards # [ tag, scaling, units ] problem.objective = np.array([ ['objective', 23000., Units.kg], ]) # ------------------------------------------------------------------- # Constraints # ------------------------------------------------------------------- # [ tag, sense, edge, scaling, units ] # CONSTRAINTS ARE SET TO BE BIGGER THAN ZERO, SEE PROCEDURE (SciPy's SLSQP optimization algorithm assumes this form) problem.constraints = np.array([ ['mzfw_consistency', '=', 0., 1000., Units.kg], # MZFW consistency ['fuel_margin', '=', 0., 1000., Units.kg], # fuel margin defined here as fuel ['Throttle_min', '>', 0., 1., Units.less], ['Throttle_max', '>', 0., 1., Units.less], ['tofl_mtow_margin', '>', 0., 100., Units.m], # take-off field length ['design_range_ub', '>', 0., 10., Units.nautical_miles], # Range consistency ['design_range_lb', '>', 0., 10., Units.nautical_miles], # Range consistency ['time_to_climb', '>', 0., 10., Units.min], # Time to climb consistency ['climb_gradient', '>', 0., 1., Units.less], # second segment climb gradient ['lfl_mlw_margin', '>', 0., 100., Units.m], # landing field length ['max_fuel_margin', '>', 0., 100., Units.kg], # max fuel margin ['TOW_HH_margin', '>', 0., 100., Units.kg], # TOW for Hot and High ]) # ------------------------------------------------------------------- # Aliases # ------------------------------------------------------------------- # [ 'alias' , ['data.path1.name','data.path2.name'] ] problem.aliases = [ [ 'wing_area', [ 'vehicle_configurations.*.wings.main_wing.areas.reference', 'vehicle_configurations.*.reference_area' ] ], [ 'aspect_ratio', 'vehicle_configurations.*.wings.main_wing.aspect_ratio' ], [ 't_c_ratio', 'vehicle_configurations.*.wings.main_wing.thickness_to_chord' ], [ 'sweep_angle', 'vehicle_configurations.*.wings.main_wing.sweeps.quarter_chord' ], ['cruise_range', 'missions.base.segments.cruise.distance'], ['fuel_margin', 'summary.fuel_margin'], ['Throttle_min', 'summary.throttle_min'], ['Throttle_max', 'summary.throttle_max'], ['tofl_mtow_margin', 'summary.takeoff_field_length_margin'], ['mzfw_consistency', 'summary.mzfw_consistency'], ['design_range_ub', 'summary.design_range_ub'], ['design_range_lb', 'summary.design_range_lb'], ['time_to_climb', 'summary.time_to_climb'], ['climb_gradient', 'summary.climb_gradient'], ['lfl_mlw_margin', 'summary.lfl_mlw_margin'], ['max_fuel_margin', 'summary.max_fuel_margin'], ['TOW_HH_margin', 'summary.TOW_HH_margin'], [ 'MTOW', [ 'vehicle_configurations.*.mass_properties.max_takeoff', 'vehicle_configurations.*.mass_properties.takeoff' ] ], ['MZFW_ratio', 'summary.MZFW_ratio'], ['beta', 'vehicle_configurations.base.wings.main_wing.beta'], ['objective', 'summary.objective'], ] # ------------------------------------------------------------------- # Vehicles # ------------------------------------------------------------------- nexus.vehicle_configurations = Vehicles.setup() # ------------------------------------------------------------------- # Analyses # ------------------------------------------------------------------- nexus.analyses = Analyses.setup(nexus.vehicle_configurations) nexus.analyses.vehicle = Data() nexus.analyses.vehicle = nexus.vehicle_configurations.base # ------------------------------------------------------------------- # Missions # ------------------------------------------------------------------- nexus.missions = Missions.setup(nexus.analyses) # ------------------------------------------------------------------- # Procedure # ------------------------------------------------------------------- nexus.procedure = Procedure.setup() # ------------------------------------------------------------------- # Summary # ------------------------------------------------------------------- nexus.summary = Data() nexus.total_number_of_iterations = 0 nexus.beta = Data() nexus.beta = 1. return nexus