def create_sol():
desvar = DesignVariables()
struct_lift_model = Surfpack('STRUCT_LIFT', desvar.ndim - 2)
struct_lift_model.load_model('struct_lift.sps')
struct_drag_model = Surfpack('STRUCT_DRAG', desvar.ndim - 2)
struct_drag_model.load_model('struct_drag.sps')
lift_model = Surfpack('LIFT', desvar.ndim)
lift_model.load_model('../FLIGHT_MECHANICS/model_lift_sup.sps')
drag_model = Surfpack('DRAG', desvar.ndim)
drag_model.load_model('../FLIGHT_MECHANICS/model_drag_sup.sps')
mach_vec = [1.2, 1.5, 1.7, 2.0, 3.0, 5.0, 7.0]
aoa_range = [[0.0, 15.0], [0.0, 17.0], [2.5, 19.0], [2.5, 20.0],
[5.0, 25.0], [7.5, 35.0], [15.0, 40.0]]
nx = 100
fig_1 = plt.figure(1)
fig_2 = plt.figure(2)
for mach_index in range(len(mach_vec)):
mach = mach_vec[mach_index]
aoa_vec = numpy.linspace(aoa_range[mach_index][0],
aoa_range[mach_index][1], nx)
lift_vec = numpy.zeros(len(aoa_vec))
drag_vec = numpy.zeros(len(aoa_vec))
struct_lift_vec = numpy.zeros(len(aoa_vec))
struct_drag_vec = numpy.zeros(len(aoa_vec))
for aoa_index in range(len(aoa_vec)):
dvs = desvar.reverse_variable_change([
mach, 1E7, aoa_vec[aoa_index], 0.0, 0.0, -0.5, 0.5, 0.0, 0.0,
0.0, 0.0
])
dvs[desvar.
rey_index] = 0.0 # Force Reynolds to Reference Trajectory
dvs_filtered = dvs[0:3] + dvs[5:11]
lift_vec[aoa_index] = lift_model.eval(dvs)
drag_vec[aoa_index] = drag_model.eval(dvs)
struct_lift_vec[aoa_index] = struct_lift_model.eval(dvs_filtered)
struct_drag_vec[aoa_index] = struct_drag_model.eval(dvs_filtered)
plt.figure(1)
plt.plot(aoa_vec, lift_vec, 'b')
plt.plot(aoa_vec, struct_lift_vec, 'r')
plt.figure(2)
plt.plot(aoa_vec, drag_vec, 'b')
plt.plot(aoa_vec, struct_drag_vec, 'r')
plt.figure(1)
plt.title('Lift Coefficient', fontsize=18)
plt.xlabel('AoA [Deg]', fontsize=18)
plt.legend(mach_vec, title='Mach')
plt.figure(2)
plt.title('Drag Coefficient', fontsize=18)
plt.xlabel('AoA [Deg]', fontsize=18)
plt.legend(mach_vec, title='Mach')
fig_1.savefig('fig_lift.png')
fig_2.savefig('fig_drag.png')
plt.close(fig_1)
plt.close(fig_2)
def response_surface( filename ,
project_folder ,
initiate = True ,
partitions = 0 ):
# Project
if os.path.exists(project_folder):
project = SPACE.io.load_data(os.path.join(project_folder,'project.pkl'))
project.compile_designs()
config = project.config
else:
config = SPACE.io.Config(filename)
state = SPACE.io.State()
project = SPACE.project.Project(config, state, folder=project_folder)
# Start new model
konfig = copy.deepcopy(config)
aero = spacemodel.AeroModel(konfig,project_folder)
# Design Variables
XB = np.array([
[0.3, 8.0], # dv_mach
[-1.0, 1.0], # dv_rey
[-1.0, 1.0], # dv_aoa # CHEAT UPPER BOUND AOA
[-0.5, 0.5], # dv_geo1
[-0.5, 0.5], # dv_geo2
[-0.5, 0.5], # dv_geo3
[-0.2, 0.5], # dv_geo4
])
ndim = 7
flag = 'K_ALPHA_FWD'
if initiate:
nd = 400 #10*ndim
X = LHC_unif(XB,nd)
model = Surfpack(flag,ndim)
for index in range(len(X)):
print X[index]
perfo_dvs = X[index]
aero_dvs = perfo_to_aero(perfo_dvs)
val = eval_function(flag,aero,aero_dvs)
if abs(val) < max_admissible(flag):
model.add(perfo_dvs,val)
model.save_data(os.path.join(project_folder,'build_points_' + flag + '.dat'))
else:
na = 500
model = Surfpack(flag,ndim)
model.load_data(os.path.join(project_folder,'build_points_' + flag + '.dat'))
model.build('kriging')
model.save_model(os.path.join(project_folder,'model_' + flag + '.sps'))
for ite in range(na):
print 'Ite:', ite
model.build('kriging')
print 'Model built'
perfo_dvs = model.max_variance(XB)
print 'dvs: ', perfo_dvs
aero_dvs = perfo_to_aero(perfo_dvs)
val = eval_function(flag,aero,aero_dvs)
if abs(val) < max_admissible(flag):
model.add(perfo_dvs,val)
model.save_data(os.path.join(project_folder,'enriched_points_' + flag + '.dat'))
# Save Model
model.build('kriging')
model.save_model(os.path.join(project_folder,'model_' + flag + '.sps'))
def eval_design(func_name, config):
""" interface for async jobs
"""
design_filename = 'design.pkl'
if os.path.exists(design_filename):
design = spaceio.load_data(design_filename)
design.config = config
save_data(design.filename,design)
else:
design = init_design(config)
save_data(design.filename,design)
# ##################
# config = SPACE.io.Config('config_DSN.cfg')
# design.config = config
# ##################
load_models = False
if load_models:
desvar = DesignVariables()
n_models = 2180
models_folder = '../../../RESPONSE_SURFACE_DV_SUP/DESIGNS/MODELS'
for index in range(n_models):
cp_model = Surfpack('CP_%05d' % (index+1), desvar.ndim)
cp_model.load_model(os.path.join(models_folder,'model_cp_%05d.sps' % (index+1)))
for index in range(n_models):
cfx_model = Surfpack('CFX_%05d' % (index+1), desvar.ndim)
cfx_model.load_model(os.path.join(models_folder,'model_cfx_%05d.sps' % (index+1)))
for index in range(n_models):
cfy_model = Surfpack('CFY_%05d' % (index+1), desvar.ndim)
cfy_model.load_model(os.path.join(models_folder,'model_cfy_%05d.sps' % (index+1)))
for index in range(n_models):
cfz_model = Surfpack('CFZ_%05d' % (index+1), desvar.ndim)
cfz_model.load_model(os.path.join(models_folder,'model_cfz_%05d.sps' % (index+1)))
if func_name == 'AERODYNAMICS':
# design.func('GEOMETRY') # this way, will save intermadiate design
# design.func('FLUID_MESH') # this way, will save intermadiate design
design.func(func_name)
else:
design.func(func_name)
def create_sol(regime='BOTH'):
n_models = 132
models_folder = 'MODELS'
build_points_folder = 'BUILD_POINTS'
desvar = DesignVariables()
if regime == 'ON':
ndim_struct = desvar.ndim_struct_on
pack_structure = desvar.pack_structure_on
dry_mass_index = 3
fuel_mass_index = 4
thrust_index = 5
pdyn_index = 6
dv1_index = 7
dv2_index = 8
dv3_index = 9
dv4_index = 10
dv5_index = 11
dv6_index = 12
elif regime == 'OFF':
ndim_struct = desvar.ndim_struct_off
pack_structure = desvar.pack_structure_off
dry_mass_index = 3
pdyn_index = 4
dv1_index = 5
dv2_index = 8
dv3_index = 7
dv4_index = 8
dv5_index = 9
dv6_index = 10
elif regime == 'BOTH':
ndim_struct = desvar.ndim_struct
pack_structure = desvar.pack_structure
thrust_index = 5
pdyn_index = 6
dv1_index = 8
dv2_index = 9
dv3_index = 10
dv4_index = 11
dv5_index = 12
dv6_index = 13
mass_models = []
for index in range(n_models):
mass_model = Surfpack('MASS_%05d' % (index + 1), ndim_struct)
mass_model.load_model(
os.path.join(models_folder, 'model_mass_%05d.sps' % (index + 1)))
mass_models.append(mass_model)
mass_models[29 - 1] = 1.480621e+00
mass_models[87 - 1] = 1.419052e+00
mass_models[88 - 1] = 1.542190e+00
mass_models[119 - 1] = 4.657316e+00
mass_models[122 - 1] = 6.165402e+00
# area_models = []
# for index in range(n_models):
# area_model = Surfpack('AREA_%05d' % (index+1), ndim_struct)
# area_model.load_model(os.path.join(models_folder,'model_area_%05d.sps' % (index+1)))
# area_models.append(area_model)
# area_models[29-1] = 3.328734e-01
# area_models[87-1] = 3.190315e-01
# area_models[88-1] = 3.467154e-01
# area_models[119-1] = 1.047058e+00
# area_models[122-1] = 1.386107e+00
# thickness_models = []
# for index in range(n_models):
# thickness_model = Surfpack('THICKNESS_%05d' % (index+1), ndim_struct)
# thickness_model.load_model(os.path.join(models_folder,'model_thickness_%05d.sps' % (index+1)))
# thickness_models.append(thickness_model)
# thickness_models[29-1] = 1.600000e-03
# thickness_models[87-1] = 1.600000e-03
# thickness_models[88-1] = 1.600000e-03
# thickness_models[119-1] = 1.600000e-03
# thickness_models[122-1] = 1.600000e-03
# thickness_models = []
# thickness_clfs = []
# thickness_values = []
# for index in range(n_models):
# dat_file = os.path.join(build_points_folder,'enriched_points_thickness_%05d.dat' % (index+1))
# clf, values, X_train, y_train = get_clf(dat_file)
# thickness_clfs.append(clf)
# thickness_values.append(values)
# count = 0
# thicknesses = []
# for dvs in X_train:
# proba = clf.predict_proba([dvs])[0]
# thickness = values[numpy.argmax(proba)]
# if not thickness: count += 1
# thicknesses.append(thickness)
# print index+1, count
# if count > 10:
# def pareto_function(x):
# F = [abs(clf.predict_proba([x])[0][0]-0.5)] # NEED TO SOLVE FOR BOTH BOUNDARIES, ONLY LOWER BOUNDARY SO FAR
# G = []
# if len(F)==1: F=F[0]
# fail = 0
# return F,G,fail
# prob = pyOpt.Optimization('Variance Maximization',pareto_function)
# XB = desvar.XB_STRUCT
# for ix in range(XB.shape[0]):
# prob.addVar('X%i'%ix,'c',lower=XB[ix,0],upper=XB[ix,1],value=0.5*(XB[ix,0]+XB[ix,1]))
# prob.addObj('Estimated Variance')
# opt_ALPSO = pyOpt.ALPSO(pll_type=None)
# opt_ALPSO.setOption('fileout',0)
# opt_ALPSO.setOption('maxOuterIter',10)
# opt_ALPSO.setOption('stopCriteria',1)
# opt_ALPSO.setOption('SwarmSize',ndim_struct*20)
# [YI_min,X_min,Info] = opt_ALPSO(prob)
# print X_min.tolist()
# print clf.predict_proba([X_min.tolist()])[0]
# print '---------------------'
# # filename = os.path.join(models_folder,'model_thickness_filtered_%05d.sps' % (index+1))
# # if os.path.exists(filename):
# # thickness_model = Surfpack('THICKNESS_%05d' % (index+1), ndim_struct)
# # thickness_model.load_model(filename)
# # thickness_models.append(thickness_model)
# # else:
# # thickness_models.append(None)
# sys.exit()
structure_mass_model = Surfpack('STRUCTURE_MASS', ndim_struct)
structure_mass_model.load_model(
os.path.join(models_folder, 'model_structure_mass.sps'))
structure_area_model = Surfpack('STRUCTURE_AREA', ndim_struct)
structure_area_model.load_model(
os.path.join(models_folder, 'model_structure_area.sps'))
# structure_mass_model_538 = Surfpack('STRUCTURE_MASS_538', ndim_struct)
# structure_mass_model_538.load_model(os.path.join(models_folder,'model_structure_mass_538.sps'))
# if regime == 'ON':
# print '///////////////////////////////////'
# dvs = [8, -8.154462e-01 , -3.769461e-01, 2.105852e+04 , 2.353362e+04 , 1.514796e+06 , 2.065276e+04 , 1.156752e-01 , -1.911024e-01, -4.267155e-01, -1.732892e-01 , -3.821894e-01 , 6.623392e-02]
# dvs = [6.681148e+00 , 3.875544e-02 , -4.776890e-01 , 5.181418e+03 , 1.119053e+04 , 1.802179e+05 , 6.625015e+03 , 4.811014e-01 , -1.691460e-01 , -1.736698e-01 , 2.441538e-01 , -3.857268e-01 , 7.727754e-03]
# print structure_mass_model.eval(dvs)
# half_structure_mass_compounded = 0
# for index in range(n_models):
# area = area_models[index].eval(dvs)
# thickness = thickness_models[index].eval(dvs)
# if thickness < 0.0016: thickness = 0.0016
# half_structure_mass_compounded += area*thickness*2780.0
# print half_structure_mass_compounded
# dvs = [3 , 1.000000e+00, -4.428224e-01 , 3.000000e+04 , 0.000000e+00 , 1.000000e+05 , 1.000000e-06 , -5.000000e-01, -5.000000e-01 , -5.000000e-01 , -2.000000e-01 , -5.000000e-01 , -2.000000e-01]
# print structure_mass_model.eval(dvs)
# half_structure_mass_compounded = 0
# for index in range(n_models):
# half_structure_mass_compounded += mass_models[index].eval(dvs)
# print half_structure_mass_compounded
# dvs = [8 , 4.778873e-01 ,7.637604e-01 , 6.573100e+03 , 1.946402e+03 , 2.520920e+06 , 2.220040e+04 , -3.427057e-01 , 9.163581e-02 , -1.100301e-01 , 3.888815e-01 , 4.278542e-01 , 3.149009e-01]
# print structure_mass_model.eval(dvs)
# half_structure_mass_compounded = 0
# for index in range(n_models):
# half_structure_mass_compounded += mass_models[index].eval(dvs)
# print half_structure_mass_compounded
# print '///////////////////////////////////'
# for val in numpy.linspace(-0.5,0.5,10.0):
# dvs[dv2_index] = val
# mass = 0
# for index in range(n_models):
# mass += mass_models[index].eval(dvs)
# print mass
# print mass_models[49].eval(dvs)
if regime == 'ON':
#dvs = [1.1,0.0,1.0,20.0e3,20.0e3,2.5e6,20.0e3,0.0,0.0,0.0,0.0,0.0,0.0]
dvs_baseline = [
1.1, 0.0, 1.0, 20.0e3, 20.0e3, 2.5e6, 20.0e3, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0
]
#dvs_baseline = [6.681148e+00 , 3.875544e-02 , -4.776890e-01 , 5.181418e+03 , 1.119053e+04 , 1.802179e+05 , 6.625015e+03 , 4.811014e-01 , -1.691460e-01 , -1.736698e-01 , 2.441538e-01 , -3.857268e-01 , 7.727754e-03]
elif regime == 'OFF':
#dvs = [3.5,0.0,0.0,20.0e3,20.0e3,0.0,0.0,0.0,0.0,0.0,0.0]
dvs_baseline = [
1.1, 0.0, 1.0, 20.0e3, 20.0e3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]
elif regime == 'BOTH':
#dvs = [3.5,0.0,0.0,20.0e3,20.0e3,0.0,0.0,0.0,0.0,0.0,0.0]
dvs_baseline = [
1.1, 0.0, 1.0, 3.0, -3.0, 1.5e6, 20.0e3, 20.0e3, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0
]
# Midpoint
dvs_baseline = [
4.5, 0.0, 0.0, 3.0, -3.0, 1.5e6, 20.0e3, 14.0e3, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0
]
print 'FIG 1'
data_vals = numpy.linspace(0.1e6, 3.0e6, 10.0)
data_thrust = [
4649.719614, 4687.683943, 4821.850514, 4973.544549, 5123.671123,
5284.42803, 5458.613164, 5680.410132, 5954.866974, 6221.018232
]
fig = plt.figure()
vals = numpy.linspace(0.1e6, 3.0e6, 10.0)
for dv_index in [thrust_index]:
half_structure_masses = []
half_structure_masses_compounded = []
for val in vals:
dvs = copy.copy(dvs_baseline)
dvs[dv_index] = val
#dvs[dry_mass_index] = 20.e3
half_structure_mass = structure_mass_model.eval(dvs)
#effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass, dvs, regime)
# for index in range(10):
# dvs[dry_mass_index] = 2.0*effective_half_dry_mass
# half_structure_mass = structure_mass_model.eval(dvs)
# effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass, dvs, regime)
half_structure_masses.append(half_structure_mass)
#dvs[dry_mass_index] = 20.e3
# half_structure_mass_compounded = 0
# for index in range(n_models):
# area = area_models[index].eval(dvs)
# thickness = thickness_models[index].eval(dvs)
# if thickness < 0.0016: thickness = 0.0016
# half_structure_mass_compounded += area*thickness*2780.0
#effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass_compounded, dvs, regime)
# for index in range(10):
# dvs[dry_mass_index] = 2.0*effective_half_dry_mass
# half_structure_mass_compounded = 0
# for index in range(n_models):
# half_structure_mass_compounded += mass_models[index].eval(dvs)
# effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass_compounded, dvs, regime)
# half_structure_masses_compounded.append(half_structure_mass_compounded)
half_structure_mass_compounded = 0
for index in range(n_models):
if isinstance(mass_models[index], float):
mass = mass_models[index]
else:
mass = mass_models[index].eval(dvs)
print mass
half_structure_mass_compounded += mass
half_structure_masses_compounded.append(
half_structure_mass_compounded)
plt.plot(vals, half_structure_masses, linestyle='-',
color='b') #, color='red')
# plt.plot(vals, half_structure_masses_compounded, linestyle='-.', color='b') #, color='red')
plt.plot(data_vals, data_thrust, linestyle='--', color='b')
plt.legend(['thrust model', 'thrust model comp', 'thrust data'])
fig.savefig('fig_1.png')
plt.close(fig)
print 'FIG 2'
data_vals = numpy.linspace(1.0e-6, 35.0e3, 10.0)
data_pdyn = [
2957.71009, 2625.264827, 3001.195708, 3736.965894, 4429.157145,
5088.273839, 5688.673517, 6294.21067, 6926.893072, 7560.110534
]
fig = plt.figure()
vals = numpy.linspace(0.0, 35.0e3, 10.0)
for dv_index in [pdyn_index]:
half_structure_masses = []
half_structure_masses_compounded = []
for val in vals:
dvs = copy.copy(dvs_baseline)
dvs[dv_index] = val
#dvs[dry_mass_index] = 20.e3
half_structure_mass = structure_mass_model.eval(dvs)
#effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass, dvs, regime)
# for index in range(10):
# dvs[dry_mass_index] = 2.0*effective_half_dry_mass
# half_structure_mass = structure_mass_model.eval(dvs)
# effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass, dvs, regime)
half_structure_masses.append(half_structure_mass)
#dvs[dry_mass_index] = 20.e3
# half_structure_mass_compounded = 0
# for index in range(n_models):
# area = area_models[index].eval(dvs)
# thickness = thickness_models[index].eval(dvs)
# if thickness < 0.0016: thickness = 0.0016
# half_structure_mass_compounded += area*thickness*2780.0
#effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass_compounded, dvs, regime)
# for index in range(10):
# dvs[dry_mass_index] = 2.0*effective_half_dry_mass
# half_structure_mass_compounded = 0
# for index in range(n_models):
# half_structure_mass_compounded += mass_models[index].eval(dvs)
# effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass_compounded, dvs, regime)
# half_structure_masses_compounded.append(half_structure_mass_compounded)
half_structure_mass_compounded = 0
for index in range(n_models):
if isinstance(mass_models[index], float):
mass = mass_models[index]
else:
mass = mass_models[index].eval(dvs)
print mass
half_structure_mass_compounded += mass
half_structure_masses_compounded.append(
half_structure_mass_compounded)
plt.plot(vals, half_structure_masses, linestyle='-',
color='b') #, color='red')
# plt.plot(vals, half_structure_masses_compounded, linestyle='-.', color='b') #, color='red')
plt.plot(data_vals, data_pdyn, linestyle='--', color='b')
plt.legend(['pdyn model', 'pdyn data'])
fig.savefig('fig_2.png')
plt.close(fig)
print 'FIG 3'
data_vals = numpy.linspace(-0.5, 0.5, 10.0)
data_dv1 = [
5590.589805, 5533.773873, 5380.979267, 5298.78498, 5217.45326,
5137.956884, 5053.125224, 4968.984914, 4911.796718, 4867.404202
]
data_dv2 = [
4758.01053, 4856.109344, 4953.734989, 5037.584574, 5121.434159,
5247.678988, 5378.20162, 5499.651994, 5611.571558, 5718.533598
]
data_dv3 = [
4505.383296, 4644.681223, 4782.928996, 4937.26097, 5097.557156,
5257.873734, 5416.235764, 5573.284102, 5731.643236, 5885.3711
]
fig = plt.figure()
vals = numpy.linspace(-0.5, 0.5, 10.0)
# eval_indexes = []
# dvs = copy.copy(dvs_baseline)
# for index in range(n_models):
# proba = thickness_clfs[index].predict_proba([dvs])
# thickness = thickness_values[index][numpy.argmin(proba)]
# if thickness == 0.0016: eval_indexes.append(index)
# eval_indexes = range(132) #eval_indexes[0:3]
# print len(eval_indexes)
# print eval_indexes
# dat_file = os.path.join(build_points_folder,'enriched_points_mass_00001.dat')
# data = numpy.loadtxt(dat_file)
# intermediate_masses = [0.0 for index in range(len(data))]
# for index in eval_indexes:
# dat_file = os.path.join(build_points_folder,'enriched_points_mass_%05d.dat' % (index+1))
# data = numpy.loadtxt(dat_file)
# for index_data in range(len(intermediate_masses)):
# val = data[index_data][-1]
# intermediate_masses[index_data] += val
# intermediate_mass_model = Surfpack('INTERMEDIATE_MASS', ndim_struct)
# dat_file = os.path.join(build_points_folder,'enriched_points_mass_00001.dat')
# data = numpy.loadtxt(dat_file)
# for index_data in range(0,len(data)):
# dvs = data[index_data][0:-1]
# intermediate_mass_model.add(dvs, intermediate_masses[index_data])
# print 'BUILDING'
# intermediate_mass_model.build('kriging')
# dat_file = os.path.join(build_points_folder,'enriched_points_mass_00001.dat')
# data = numpy.loadtxt(dat_file)
# dvs = data[0][0:-1]
# eval_indexes = []
# for index in range(n_models):
# proba = thickness_clfs[index].predict_proba([dvs])
# thickness = thickness_values[index][numpy.argmin(proba)]
# if thickness == 0.0016: eval_indexes.append(index)
# print '/////////////////////////////////////////////'
# print dvs
# intermediate_masses = 0.0
# for index in eval_indexes:
# dat_file = os.path.join(build_points_folder,'enriched_points_area_%05d.dat' % (index+1))
# data = numpy.loadtxt(dat_file)
# val = data[0][-1]
# intermediate_masses += val
# print intermediate_masses
# half_structure_mass_compounded = 0.0
# for index in eval_indexes:
# area = area_models[index].eval(dvs)
# proba = thickness_clfs[index].predict_proba([dvs])
# thickness = thickness_values[index][numpy.argmin(proba)]
# half_structure_mass_compounded += area #*thickness*2780.0
# print half_structure_mass_compounded
# print '/////////////////////////////////////////////'
colors = ['b', 'r', 'g']
counter = 0
for dv_index in [dv1_index, dv2_index, dv3_index]:
print dv_index
half_structure_masses = []
half_intermediate_masses = []
half_structure_masses_compounded = []
for val in vals:
dvs = copy.copy(dvs_baseline)
dvs[dv_index] = val
half_structure_mass = structure_mass_model.eval(dvs)
half_structure_masses.append(half_structure_mass)
# half_intermediate_mass = intermediate_mass_model.eval(dvs)
# half_intermediate_masses.append(half_intermediate_mass)
half_structure_mass_compounded = 0
for index in range(n_models):
if isinstance(mass_models[index], float):
mass = mass_models[index]
else:
mass = mass_models[index].eval(dvs)
half_structure_mass_compounded += mass
# if isinstance(area_models[index], float):
# area = area_models[index]
# else:
# area = area_models[index].eval(dvs)
# if isinstance(thickness_models[index], float):
# thickness = thickness_models[index]
# else:
# thickness = thickness_models[index].eval(dvs)
# thickness = max(0.0016,min(0.1,thickness))
# proba = thickness_clfs[index].predict_proba([dvs])
# thickness = thickness_values[index][numpy.argmin(proba)]
# half_structure_mass_compounded += area*thickness*2780.0
half_structure_masses_compounded.append(
half_structure_mass_compounded)
plt.plot(vals, half_structure_masses,
color=colors[counter]) #, color='red')
# plt.plot(vals, half_structure_masses_compounded, linestyle='-.', color=colors[counter]) #, color='red')
counter += 1
#plt.plot(vals, half_intermediate_masses) #, color='red')
#plt.plot(vals, half_structure_masses_compounded) #, color='red')
# plt.plot(data_vals, data_dv1, linestyle='--', color='b')
# plt.plot(data_vals, data_dv2, linestyle='--', color='r')
# plt.plot(data_vals, data_dv3, linestyle='--', color='g')
plt.legend([
'dv1 model', 'dv2 model', 'dv3 model', 'dv1 data', 'dv2 data',
'dv3 data'
])
#effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass_compounded, dvs, regime)
# for index in range(10):
# dvs[dry_mass_index] = 2.0*effective_half_dry_mass
# half_structure_mass_compounded = 0
# for index in range(n_models):
# half_structure_mass_compounded += mass_models[index].eval(dvs)
# effective_half_dry_mass = compute_effective_half_dry_mass(half_structure_mass_compounded, dvs, regime)
print 'Save'
fig.savefig('fig_3.png')
plt.close(fig)
def process_design(regime='BOTH'):
original = False
number_ini = 0
range_number = 840
if original:
build_points_folder = 'BUILD_POINTS_ORIGINAL'
designs_folder = 'DESIGNS_BATCH_1'
else:
build_points_folder = 'BUILD_POINTS'
designs_folder = 'DESIGNS'
desvar = DesignVariables()
if regime == 'ON':
ndim_struct = desvar.ndim_struct_on
pack_structure = desvar.pack_structure_on
elif regime == 'OFF':
ndim_struct = desvar.ndim_struct_off
pack_structure = desvar.pack_structure_off
elif regime == 'BOTH':
ndim_struct = desvar.ndim_struct
pack_structure = desvar.pack_structure
threshold = 1.0001
mass_models = []
for index in range(132):
mass_model = Surfpack('MASS_%05d' % (index + 1), ndim_struct)
# if original:
# mass_model.load_data(os.path.join(build_points_folder,'build_points_mass_%05d.dat' % (index+1)))
# else:
# mass_model.load_data(os.path.join('BUILD_POINTS_ORIGINAL','enriched_points_mass_%05d.dat' % (index+1)))
mass_models.append(mass_model)
thickness_models = []
for index in range(132):
thickness_model = Surfpack('THICKNESS_%05d' % (index + 1), ndim_struct)
# if original:
# thickness_model.load_data(os.path.join(build_points_folder,'build_points_thickness_%05d.dat' % (index+1)))
# else:
# thickness_model.load_data(os.path.join('BUILD_POINTS_ORIGINAL','enriched_points_thickness_%05d.dat' % (index+1)))
thickness_models.append(thickness_model)
area_models = []
for index in range(132):
area_model = Surfpack('AREA_%05d' % (index + 1), ndim_struct)
# if original:
# area_model.load_data(os.path.join(build_points_folder,'build_points_area_%05d.dat' % (index+1)))
# else:
# area_model.load_data(os.path.join('BUILD_POINTS_ORIGINAL','enriched_points_area_%05d.dat' % (index+1)))
area_models.append(area_model)
structure_mass_model = Surfpack('STRUCTURE_MASS', ndim_struct)
structure_area_model = Surfpack('STRUCTURE_AREA', ndim_struct)
# if original:
# structure_mass_model.load_data(os.path.join(build_points_folder,'build_points_STRUCTURE_MASS.dat'))
# structure_area_model.load_data(os.path.join(build_points_folder,'build_points_STRUCTURE_AREA.dat'))
# else:
# structure_mass_model.load_data(os.path.join('BUILD_POINTS_ORIGINAL','enriched_points_STRUCTURE_MASS.dat'))
# structure_area_model.load_data(os.path.join('BUILD_POINTS_ORIGINAL','enriched_points_STRUCTURE_AREA.dat'))
for dsn_index in range(number_ini, range_number):
design_folder = os.path.join(designs_folder,
'DSN_%03d' % (dsn_index + 1))
history_file_name = os.path.join(design_folder,
'STRUCTURE/history_structure.dat')
mass_file_name = os.path.join(design_folder,
'STRUCTURE/lc0_mass_member.dat')
thickness_file_name = os.path.join(design_folder,
'STRUCTURE/lc0_x_final.dat')
postpro_file_name = os.path.join(design_folder,
'STRUCTURE/postpro_load_1.dat')
if os.path.exists(history_file_name) and os.path.exists(
mass_file_name) and os.path.exists(
postpro_file_name) and os.path.exists(thickness_file_name):
history = numpy.loadtxt(history_file_name,
delimiter=',',
skiprows=1)
structure_mass = history[-1, 1]
check = history[-1, 2:5]
if (check[0] < threshold) and (check[1] < threshold) and (
check[2] < threshold):
if structure_mass > 0.0 and structure_mass < 8000.0:
print dsn_index + 1, ': Success'
config = spaceio.Config(
os.path.join(design_folder, 'config_DSN.cfg'))
dvs = pack_structure(config)
structure_mass_model.add(dvs, structure_mass)
mass_data = numpy.loadtxt(mass_file_name)
for index, mass_model in enumerate(mass_models):
mass_model.add(dvs, mass_data[index])
thickness_data = numpy.loadtxt(thickness_file_name)
for index, thickness_model in enumerate(thickness_models):
thickness_model.add(dvs, thickness_data[index])
structure_area = 0
for index, area_model in enumerate(area_models):
area = mass_data[index] / thickness_data[
index] / float(config.MATERIAL_DENSITY)
area_model.add(dvs, area)
structure_area += area
structure_area_model.add(dvs, structure_area)
else:
print dsn_index + 1, ': Too Big or Too Small'
else:
print dsn_index + 1, ': Warning: ', check[0], check[1], check[
2]
else:
print 'Missing:', dsn_index + 1
structure_mass_model.save_data(
os.path.join(build_points_folder,
'enriched_points_STRUCTURE_MASS.dat'))
structure_area_model.save_data(
os.path.join(build_points_folder,
'enriched_points_STRUCTURE_AREA.dat'))
for index, mass_model in enumerate(mass_models):
print 'Save MASS: ', index
mass_model.save_data(
os.path.join(build_points_folder,
'enriched_points_mass_%05d.dat' % (index + 1)))
for index, thickness_model in enumerate(thickness_models):
print 'Save THICKNESS: ', index
thickness_model.save_data(
os.path.join(build_points_folder,
'enriched_points_thickness_%05d.dat' % (index + 1)))
for index, area_model in enumerate(area_models):
print 'Save AREA: ', index
area_model.save_data(
os.path.join(build_points_folder,
'enriched_points_area_%05d.dat' % (index + 1)))
def process_design():
range_number = 300
desvar = DesignVariables()
build_points_folder = 'BUILD_POINTS'
lift_model = Surfpack('LIFT', desvar.ndim - 2)
lift_model.load_data(
os.path.join(build_points_folder,
'build_points_struct_lift_model.dat'))
drag_model = Surfpack('DRAG', desvar.ndim - 2)
drag_model.load_data(
os.path.join(build_points_folder,
'build_points_struct_drag_model.dat'))
threshold = 1.0001
for dsn_index in range(range_number):
design_folder = 'DESIGNS/DSN_%03d' % (dsn_index + 1)
print design_folder
postpro_file_name = os.path.join(design_folder,
'STRUCTURE/postpro_load_1.dat')
history_file_name = os.path.join(design_folder,
'STRUCTURE/history_structure.dat')
mass_file_name = os.path.join(design_folder,
'STRUCTURE/lc0_mass_member.dat')
postpro_file_name = os.path.join(design_folder,
'STRUCTURE/postpro_load_1.dat')
if os.path.exists(history_file_name) and os.path.exists(
mass_file_name) and os.path.exists(postpro_file_name):
history = numpy.loadtxt(history_file_name,
delimiter=',',
skiprows=1)
structure_mass = history[-1, 1]
check = history[-1, 2:5]
if (check[0] < threshold) and (check[1] < threshold) and (
check[2] < threshold):
config = spaceio.Config(
os.path.join(design_folder, 'config_DSN.cfg'))
dvs = desvar.pack(config)
dvs_filtered = dvs[0:3] + dvs[5:11]
print dvs_filtered
with open(postpro_file_name) as fp:
for i, line in enumerate(fp):
if i == 13:
data = line.split(':')[-1].split(',')
lift = float(data[0])
drag = float(data[1])
print lift, drag
elif i > 13:
break
lift_model.add(dvs_filtered, lift)
drag_model.add(dvs_filtered, drag)
lift_model.save_data(
os.path.join(build_points_folder,
'enriched_points_struct_lift_model.dat'))
drag_model.save_data(
os.path.join(build_points_folder,
'enriched_points_struct_drag_model.dat'))
lift_model.build('kriging')
drag_model.build('kriging')
lift_model.save_model('struct_lift.sps')
drag_model.save_model('struct_drag.sps')
def load_models(filename, project_folder, regime='SUP'):
# Project
if os.path.exists(project_folder):
project = SPACE.io.load_data(
os.path.join(project_folder, 'project.pkl'))
project.compile_designs()
config = project.config
else:
config = SPACE.io.Config(filename)
state = SPACE.io.State()
project = SPACE.project.Project(config, state, folder=project_folder)
# Mission
# mission_data = np.loadtxt('output_spaceplane.dat',skiprows=1)
# mission_phase = mission_data[:,1]
# mission_altitude = mission_data[:,2]
# indexes_phase_asc = [n for n,i in enumerate(mission_phase) if i in [1,2]]
# indexes_phase_dsc = [n for n,i in enumerate(mission_phase) if i in [3,4,5,6]]
# indexes_phase_noaero = [n for n,i in enumerate(mission_altitude) if i > 80.0]
# indexes_phase_dsc_noaero = []
# indexes_phase_dsc_aero = []
# for index in indexes_phase_dsc:
# if index in indexes_phase_noaero:
# indexes_phase_dsc_noaero.append(index)
# else:
# indexes_phase_dsc_aero.append(index)
# mission_aoa = mission_data[:,9]
# mission_mach = mission_data[:,26]
# mission_reynolds = mission_data[:,27]
# Plot
nx = 100
mach_range = [0.0, 9.0]
aoa_range = [0.0, 55.0]
cogs = [0.60 * 17, 0.63 * 17]
cog_z = -0.3
ndim = 7
aero_desvar = DesignVariables()
model_trim_fwd = Surfpack('TRIM_FWD', ndim)
model_trim_fwd.load_model(
os.path.join(project_folder, 'model_TRIM_FWD.sps'))
model_trim_aft = Surfpack('TRIM_AFT', ndim)
model_trim_aft.load_model(
os.path.join(project_folder, 'model_TRIM_AFT.sps'))
model_trimmed_static_margin_aft = Surfpack('TRIMMED_STATIC_MARGIN_AFT',
ndim)
model_trimmed_static_margin_aft.load_model(
os.path.join(project_folder, 'model_TRIMMED_STATIC_MARGIN_AFT.sps'))
model_trimmed_static_margin_fwd = Surfpack('TRIMMED_STATIC_MARGIN_FWD',
ndim)
model_trimmed_static_margin_fwd.load_model(
os.path.join(project_folder, 'model_TRIMMED_STATIC_MARGIN_FWD.sps'))
model_k_alpha_aft = Surfpack('K_ALPHA_AFT', ndim)
model_k_alpha_aft.load_model(
os.path.join(project_folder, 'model_K_ALPHA_AFT.sps'))
model_k_alpha_fwd = Surfpack('K_ALPHA_FWD', ndim)
model_k_alpha_fwd.load_model(
os.path.join(project_folder, 'model_K_ALPHA_FWD.sps'))
for flag in ['K_ALPHA']: # ['TRIM','TRIMMED_STATIC_MARGIN']: #
for shift in [0.0]:
# Small
dv1 = 0.5 + shift # Leading Edge Location
dv2 = -0.5 # Elevon Length
dv3 = -0.5 # Span
dv4 = -0.2 + shift # Hinge Location
dv5 = 0.5
dv6 = 0.5
# # Elevon
# dv1 = 0.5 + shift # Leading Edge Location
# dv2 = 0.5 # Elevon Length
# dv3 = -0.5 # Span
# dv4 = 0.5 + shift # Hinge Location
# dv5 = 0.5
# dv6 = 0.5
# # # OPTIM
# dv1 = -0.5 + shift # Leading Edge Location
# dv2 = -0.5 # Elevon Length
# dv3 = -0.5 # Span
# dv4 = -0.2 + shift # Hinge Location
# dv5 = 0.5
# dv6 = 0.5
fig = plt.figure()
plt.title(flag.replace('_', ' '), fontsize=18)
plt.xlabel('Mach', fontsize=18)
plt.ylabel('AoA [Deg]', fontsize=18)
plt.xlim([0, 9])
plt.ylim([0, 55])
plt.fill_between([0, 1, 8], [15, 15, 55], [55, 55, 55],
color='grey',
alpha='0.3',
lw=0,
zorder=3)
plt.fill_between([1, 8, 8, 9], [0, 0, 0, 0], [0, 15, 55, 55],
color='grey',
alpha='0.3',
lw=0,
zorder=3)
for index, cog_x in enumerate(cogs):
MACH = np.linspace(mach_range[0], mach_range[1], nx)
AOA = np.linspace(aoa_range[0], aoa_range[1], nx)
MACH, AOA = np.meshgrid(MACH, AOA)
COEFF = MACH * 0.0
for ix in range(nx):
for iy in range(nx):
aero_dvs = aero_desvar.reverse_variable_change(
[
MACH[ix, iy], 1E7, AOA[ix, iy], 0.0, 0.0, dv1,
dv2, dv3, dv4, dv5, dv6
]
) ##### MUST DO BETTER for Reynolds... Must be the one from trajectory!!! FOR REYNOLDS
aero_dvs[
aero_desvar.
rey_index] = 0.0 # Force Reynolds to Reference Trajectory
perfo_dvs = aero_to_perfo(aero_dvs)
if (flag == 'TRIM'):
if index == 0:
val = model_trim_fwd.eval(perfo_dvs)
else:
val = model_trim_aft.eval(perfo_dvs)
if val < aero_desvar.bf_bound[0]:
val = val - aero_desvar.bf_bound[0]
elif val > aero_desvar.bf_bound[1]:
val = val - aero_desvar.bf_bound[1]
else:
val = 0.0
COEFF[ix, iy] = val * 180.0 / np.pi
elif (flag == 'TRIMMED_STATIC_MARGIN'):
if index == 0:
COEFF[
ix,
iy] = model_trimmed_static_margin_fwd.eval(
perfo_dvs)
else:
COEFF[
ix,
iy] = model_trimmed_static_margin_aft.eval(
perfo_dvs)
elif (flag == 'K_ALPHA'):
if index == 0:
COEFF[ix,
iy] = model_k_alpha_fwd.eval(perfo_dvs)
else:
COEFF[ix,
iy] = model_k_alpha_aft.eval(perfo_dvs)
elif (flag == 'EFFICIENCY'):
COEFF[ix, iy] = 0.0
if (flag == 'TRIM'):
val = -20.0 * 0.2
levels = [-float("inf"), val]
if index == 0:
hatches = ['\\\\']
else:
hatches = ['//']
plt.contourf(MACH,
AOA,
COEFF,
levels,
colors='none',
edgecolor='r',
hatches=hatches)
levels = [val]
CS = plt.contour(MACH, AOA, COEFF, levels, colors='k')
plt.clabel(CS, inline=1, fontsize=10)
val = 30.0 * 0.2
levels = [val, float("inf")]
if index == 0:
hatches = ['\\\\']
else:
hatches = ['//']
plt.contourf(MACH,
AOA,
COEFF,
levels,
colors='none',
edgecolor='r',
hatches=hatches)
levels = [val]
CS = plt.contour(MACH, AOA, COEFF, levels, colors='k')
plt.clabel(CS, inline=1, fontsize=10)
elif (flag == 'TRIMMED_STATIC_MARGIN'):
val = -0.04
levels = [-10.0, val]
if index == 0:
hatches = ['\\\\']
else:
hatches = ['//']
plt.contourf(MACH,
AOA,
COEFF,
levels,
colors='none',
edgecolor='r',
hatches=hatches,
extend='lower')
levels = [val]
CS = plt.contour(MACH, AOA, COEFF, levels, colors='k')
plt.clabel(CS, inline=1, fontsize=10)
elif (flag == 'K_ALPHA'):
val = 4.0
levels = [val, 10000.0]
if index == 0:
hatches = ['\\\\']
else:
hatches = ['//']
plt.contourf(MACH,
AOA,
COEFF,
levels,
colors='none',
edgecolor='r',
hatches=hatches,
extend='lower')
levels = [val]
CS = plt.contour(MACH, AOA, COEFF, levels, colors='k')
plt.clabel(CS, inline=1, fontsize=10)
elif (flag == 'EFFICIENCY'):
levels = [3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0]
plt.contour(MACH, AOA, COEFF, levels)
# plt.plot(mission_mach[indexes_phase_asc], mission_aoa[indexes_phase_asc], color='red')
# plt.plot(mission_mach[indexes_phase_dsc_noaero], mission_aoa[indexes_phase_dsc_noaero], color='green')
# plt.plot(mission_mach[indexes_phase_dsc_aero], mission_aoa[indexes_phase_dsc_aero], color='blue')
fig.savefig(
os.path.join(project_folder,
'fig_' + flag + '_' + str(shift) + '.png'))
plt.close(fig)
def process_project(project_folder, max_dsn):
desvar = DesignVariables()
lift_model = Surfpack('LIFT', desvar.ndim)
drag_model = Surfpack('DRAG', desvar.ndim)
force_x_model = Surfpack('FORCE_X', desvar.ndim)
force_z_model = Surfpack('FORCE_Z', desvar.ndim)
moment_y_model = Surfpack('MOMENT_Y', desvar.ndim)
if (max_dsn == "ENRICHED"):
# Load Data
lift_model.load_data(
os.path.join(project_folder, 'enriched_points_lift.dat'))
drag_model.load_data(
os.path.join(project_folder, 'enriched_points_drag.dat'))
force_x_model.load_data(
os.path.join(project_folder, 'enriched_points_force_x.dat'))
force_z_model.load_data(
os.path.join(project_folder, 'enriched_points_force_z.dat'))
moment_y_model.load_data(
os.path.join(project_folder, 'enriched_points_moment_y.dat'))
elif (max_dsn == "BUILD"):
# Load Data
lift_model.load_data(
os.path.join(project_folder, 'build_points_lift.dat'))
drag_model.load_data(
os.path.join(project_folder, 'build_points_drag.dat'))
force_x_model.load_data(
os.path.join(project_folder, 'build_points_force_x.dat'))
force_z_model.load_data(
os.path.join(project_folder, 'build_points_force_z.dat'))
moment_y_model.load_data(
os.path.join(project_folder, 'build_points_moment_y.dat'))
else:
project = SPACE.io.load_data(
os.path.join(project_folder, 'project.pkl'))
project.compile_designs()
if (max_dsn == "ALL"):
dsn_number = len(project.designs)
else:
dsn_number = int(max_dsn)
count = 0
for index in range(dsn_number):
design_container = project.designs[index]
design = design_container.design
if not design is None:
dvs = desvar.pack(design.config)
funcs = design.funcs
if hasattr(funcs, 'LIFT') and hasattr(
funcs, 'DRAG') and hasattr(funcs, 'MOMENT_Y'):
count += 1
lift_model.add(dvs, funcs.LIFT)
drag_model.add(dvs, funcs.DRAG)
force_x_model.add(dvs, funcs.FORCE_X)
force_z_model.add(dvs, funcs.FORCE_Z)
moment_y_model.add(dvs, funcs.MOMENT_Y)
# print 'done ' + design.folder
else:
print 'missing ' + design.folder
else:
print 'missing design'
print count
# Save Data
lift_model.save_data(
os.path.join(project_folder, 'build_points_lift.dat'))
drag_model.save_data(
os.path.join(project_folder, 'build_points_drag.dat'))
force_x_model.save_data(
os.path.join(project_folder, 'build_points_force_x.dat'))
force_z_model.save_data(
os.path.join(project_folder, 'build_points_force_z.dat'))
moment_y_model.save_data(
os.path.join(project_folder, 'build_points_moment_y.dat'))
# Build Model
lift_model.build('kriging')
drag_model.build('kriging')
force_x_model.build('kriging')
force_z_model.build('kriging')
moment_y_model.build('kriging')
# Save Model
lift_model.save_model(os.path.join(project_folder, 'model_lift.sps'))
drag_model.save_model(os.path.join(project_folder, 'model_drag.sps'))
force_x_model.save_model(os.path.join(project_folder, 'model_force_x.sps'))
force_z_model.save_model(os.path.join(project_folder, 'model_force_z.sps'))
moment_y_model.save_model(
os.path.join(project_folder, 'model_moment_y.sps'))
def response_surface(filename, project_folder, initiate=False, partitions=0):
# Project
if os.path.exists(project_folder):
project = SPACE.io.load_data(
os.path.join(project_folder, 'project.pkl'))
project.compile_designs()
config = project.config
else:
config = SPACE.io.Config(filename)
state = SPACE.io.State()
project = SPACE.project.Project(config, state, folder=project_folder)
print '%d design(s) so far' % len(project.designs)
konfig = copy.deepcopy(config)
konfig.NUMBER_PART = partitions
# Design Variables
desvar = DesignVariables()
XB = desvar.XB_SUB
find_next = False
ini = 0
ini_dsn_folder = 'DSN_344'
if initiate:
nd = 10 * desvar.ndim
X = LHC_unif(XB, nd)
lift_model = Surfpack('LIFT', desvar.ndim)
drag_model = Surfpack('DRAG', desvar.ndim)
force_z_model = Surfpack('FORCE_Z', desvar.ndim)
moment_y_model = Surfpack('MOMENT_Y', desvar.ndim)
for index in range(0, len(X)):
dvs = X[index]
desvar.unpack(konfig, dvs)
lift_model.add(dvs, project.func('LIFT', konfig))
drag_model.add(dvs, project.func('DRAG', konfig))
force_z_model.add(dvs, project.func('FORCE_Z', konfig))
moment_y_model.add(dvs, project.func('MOMENT_Y', konfig))
lift_model.save_data(
os.path.join(project_folder, 'build_points_lift.dat'))
drag_model.save_data(
os.path.join(project_folder, 'build_points_drag.dat'))
force_z_model.save_data(
os.path.join(project_folder, 'build_points_force_z.dat'))
moment_y_model.save_data(
os.path.join(project_folder, 'build_points_moment_y.dat'))
else:
if (find_next):
na = ini + 1
else:
na = 500
lift_model = Surfpack('LIFT', desvar.ndim)
lift_model.load_data(
os.path.join(project_folder, 'build_points_lift.dat'))
drag_model = Surfpack('DRAG', desvar.ndim)
drag_model.load_data(
os.path.join(project_folder, 'build_points_drag.dat'))
force_z_model = Surfpack('FORCE_Z', desvar.ndim)
force_z_model.load_data(
os.path.join(project_folder, 'build_points_drag.dat'))
moment_y_model = Surfpack('MOMENT_Y', desvar.ndim)
moment_y_model.load_data(
os.path.join(project_folder, 'build_points_moment_y.dat'))
for ite in range(
ini, na): # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
print 'Ite:', ite
if ite % 3 == 0:
current_model = lift_model
elif ite % 3 == 1:
current_model = drag_model
else:
current_model = moment_y_model
if ite == ini:
if (find_next):
current_model.build('kriging')
else:
None
else:
current_model.build('kriging')
print 'Model built'
if ite == ini:
if (find_next):
dvs = current_model.max_variance(XB)
np.savetxt(os.path.join(project_folder, 'next_dvs.dat'),
dvs,
fmt='%.18e',
delimiter=', ',
newline='\n',
header='',
footer='',
comments='# ')
break
else:
dvs = np.loadtxt(os.path.join(project_folder,
'next_dvs.dat'),
delimiter=', ',
comments='# ')
else:
dvs = current_model.max_variance(XB)
np.savetxt(os.path.join(project_folder, 'next_dvs.dat'),
dvs,
fmt='%.18e',
delimiter=', ',
newline='\n',
header='',
footer='',
comments='# ')
desvar.unpack(konfig, dvs)
print '-------------------------------'
print dvs
print '-------------------------------'
if ite == ini:
proc = project.func('AERODYNAMICS', konfig, ini_dsn_folder)
else:
proc = project.func('AERODYNAMICS', konfig)
new_design_container = project.designs[-1]
proc.wait()
project.compile_designs()
new_design = new_design_container.design
if not new_design is None:
new_dvs = desvar.pack(new_design.config)
new_funcs = new_design.funcs
if hasattr(new_funcs,
'LIFT') and hasattr(new_funcs, 'DRAG') and hasattr(
new_funcs, 'FORCE_Z') and hasattr(
new_funcs, 'MOMENT_Y'):
lift_model.add(new_dvs, new_funcs.LIFT)
drag_model.add(new_dvs, new_funcs.DRAG)
force_z_model.add(new_dvs, new_funcs.FORCE_Z)
moment_y_model.add(new_dvs, new_funcs.MOMENT_Y)
lift_model.save_data(
os.path.join(project_folder, 'enriched_points_lift.dat'))
drag_model.save_data(
os.path.join(project_folder, 'enriched_points_drag.dat'))
force_z_model.save_data(
os.path.join(project_folder, 'enriched_points_force_z.dat'))
moment_y_model.save_data(
os.path.join(project_folder, 'enriched_points_moment_y.dat'))
# Save Models
lift_model.build('kriging')
drag_model.build('kriging')
force_z_model.build('kriging')
moment_y_model.build('kriging')
lift_model.save_model(os.path.join(project_folder, 'model_lift.sps'))
drag_model.save_model(os.path.join(project_folder, 'model_drag.sps'))
force_z_model.save_model(
os.path.join(project_folder, 'model_force_z.sps'))
moment_y_model.save_model(
os.path.join(project_folder, 'model_moment_y.sps'))
def build(regime='BOTH'):
models_folder = 'MODELS'
build_points_folder = 'BUILD_POINTS'
desvar = DesignVariables()
if regime == 'ON':
ndim_struct = desvar.ndim_struct_on
elif regime == 'OFF':
ndim_struct = desvar.ndim_struct_off
elif regime == 'BOTH':
ndim_struct = desvar.ndim_struct
n_models = 132
# for index in range(0,n_models):
# print 'MASS',index
# mass_model = Surfpack('MASS_%05d' % (index+1), ndim_struct)
# mass_model.load_data(os.path.join(build_points_folder,'enriched_points_mass_%05d.dat' % (index+1)))
# mass_model.build('kriging')
# mass_model.save_model(os.path.join(models_folder,'model_mass_%05d.sps' % (index+1)))
# for index in range(0,n_models):
# print 'AREA',index
# area_model = Surfpack('AREA_%05d' % (index+1), ndim_struct)
# area_model.load_data(os.path.join(build_points_folder,'enriched_points_area_%05d.dat' % (index+1)))
# area_model.build('kriging')
# area_model.save_model(os.path.join(models_folder,'model_area_%05d.sps' % (index+1)))
# for index in range(0,n_models):
# print 'THICKNESS',index
# thickness_model = Surfpack('THICKNESS_%05d' % (index+1), ndim_struct)
# thickness_model.load_data(os.path.join(build_points_folder,'enriched_points_thickness_%05d.dat' % (index+1)))
# thickness_model.build('kriging')
# thickness_model.save_model(os.path.join(models_folder,'model_thickness_%05d.sps' % (index+1)))
print 'MASS'
structure_mass_model = Surfpack('STRUCTURE_MASS', ndim_struct)
structure_mass_model.load_data(
os.path.join(build_points_folder,
'enriched_points_STRUCTURE_MASS.dat'))
structure_mass_model.build('kriging')
structure_mass_model.save_model(
os.path.join(models_folder, 'model_structure_mass.sps'))
print 'AREA'
structure_mass_model = Surfpack('STRUCTURE_AREA', ndim_struct)
structure_mass_model.load_data(
os.path.join(build_points_folder,
'enriched_points_STRUCTURE_AREA.dat'))
structure_mass_model.build('kriging')
structure_mass_model.save_model(
os.path.join(models_folder, 'model_structure_area.sps'))
def response_surface(filename,
project_folder,
regime='BOTH',
initiate=False,
partitions=0):
# Project
if os.path.exists(project_folder):
project = SPACE.io.load_data(
os.path.join(project_folder, 'project.pkl'))
project.compile_designs()
config = project.config
else:
config = SPACE.io.Config(filename)
state = SPACE.io.State()
project = SPACE.project.Project(config, state, folder=project_folder)
print '%d design(s) so far' % len(project.designs)
config.NUMBER_PART = 0
# Design Variables
desvar = DesignVariables()
# Load All Aero Models
#load_aero_models()
if regime == 'ON':
XB = desvar.XB_STRUCT_ON
ndim_struct = desvar.ndim_struct_on
unpack_structure = desvar.unpack_structure_on
pack_structure = desvar.pack_structure_on
dry_mass_index = 3
fuel_mass_index = 4
thrust_index = 5
pdyn_index = 6
dv1_index = 7
dv2_index = 8
dv3_index = 9
dv4_index = 10
dv5_index = 11
dv6_index = 12
dvs_baseline = [
1.1, 0.0, 1.0, 20.0e3, 20.0e3, 2.5e6, 20.0e3, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0
]
elif regime == 'OFF':
XB = desvar.XB_STRUCT_OFF
ndim_struct = desvar.ndim_struct_off
unpack_structure = desvar.unpack_structure_off
pack_structure = desvar.pack_structure_off
elif regime == 'BOTH':
XB = desvar.XB_STRUCT
ndim_struct = desvar.ndim_struct
unpack_structure = desvar.unpack_structure
pack_structure = desvar.pack_structure
mach_index = 0
rey_index = 1
aoa_index = 2
nx_index = 3
nz_index = 4
thrust_index = 5
pdyn_index = 6
fuel_mass_index = 7
dv1_index = 8
dv2_index = 9
dv3_index = 10
dv4_index = 11
dv5_index = 12
dv6_index = 13
dvs_baseline = [
1.1, 0.0, 1.0, 3.0, -3.0, 1.5e6, 20.0e3, 20.0e3, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0
]
# Midpoint
dvs_baseline = [
4.5, 0.0, 0.0, 3.0, -3.0, 1.5e6, 20.0e3, 14.0e3, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0
]
if initiate:
vals = np.linspace(-0.5, 0.5, 10.0)
new_dvs_vec = []
for val in vals:
dvs = copy.copy(dvs_baseline)
dvs[dv2_index] = val
new_dvs_vec.append(dvs)
procs = []
for new_dvs in new_dvs_vec:
print 'New dvs: ', new_dvs
konfig = copy.deepcopy(config)
unpack_structure(konfig, new_dvs)
proc = project.func('STRUCTURE', konfig)
procs.append(proc)
for proc in procs:
proc.wait()
vals = np.linspace(-0.5, 0.5, 10.0)
new_dvs_vec = []
for val in vals:
dvs = copy.copy(dvs_baseline)
dvs[dv3_index] = val
new_dvs_vec.append(dvs)
procs = []
for new_dvs in new_dvs_vec:
print 'New dvs: ', new_dvs
konfig = copy.deepcopy(config)
unpack_structure(konfig, new_dvs)
proc = project.func('STRUCTURE', konfig)
procs.append(proc)
for proc in procs:
proc.wait()
# # nd = ndim_struct * 10
# nd = 300
# dvs_struct_filename = 'dvs_struct_' + regime + '.dat'
# # X = LHC_unif(XB,nd)
# # np.savetxt(dvs_struct_filename,X)
# X = np.loadtxt(dvs_struct_filename)
# for index_1 in range(nd/partitions):
# procs = []
# for index_2 in range(partitions):
# index = index_1*partitions+index_2
# dvs = X[index]
# konfig = copy.deepcopy(config)
# unpack_structure(konfig, dvs)
# proc = project.func('STRUCTURE', konfig)
# # force_redo_dsn_folder = None #'DSN_001'
# # proc = project.func('STRUCTURE', konfig, force_redo_dsn_folder)
# procs.append(proc)
# for proc in procs:
# proc.wait()
else:
na = 20
number_per_ite = 12
# flag = 'DRY_MASS' # WHICH ONE ???????
flag = 'STRUCTURE_MASS'
threshold = 1.0001
build_points_folder = os.path.join(project_folder, 'BUILD_POINTS')
model = Surfpack(flag, ndim_struct)
model.load_data(
os.path.join(build_points_folder, 'build_points_' + flag + '.dat'))
exclude = []
next_dvs_vec_filename = 'next_dvs_vec_' + regime + '.dat'
# new_dvs_vec = []
# for dsn_index in range(12):
# design_folder = os.path.join(project_folder,'DESIGNS/DSN_%03d' % (dsn_index+1))
# local_config = SPACE.io.Config(os.path.join(design_folder,'config_DSN.cfg'))
# local_dvs = pack_structure(local_config)
# new_dvs_vec.append(local_dvs)
# np.savetxt(next_dvs_vec_filename, new_dvs_vec)
print 'Begin Iterating:'
for ite in range(na):
print 'Ite:', ite
# NEW POINTS
if ite == 0:
new_dvs_vec = np.loadtxt(next_dvs_vec_filename)
else:
model.build('kriging')
print 'Model built'
new_dvs_vec = model.max_variance(XB,
number=number_per_ite,
exclude=exclude)
np.savetxt(next_dvs_vec_filename, new_dvs_vec)
effective_number_per_ite = len(new_dvs_vec)
# COMPUTE
procs = []
number_design_before = len(project.designs)
for new_dvs in new_dvs_vec:
print 'New dvs: ', new_dvs
konfig = copy.deepcopy(config)
unpack_structure(konfig, new_dvs)
proc = project.func('STRUCTURE', konfig)
procs.append(proc)
for proc in procs:
proc.wait()
number_design_after = len(project.designs)
# READ RESULTS
# for dsn_index in range(number_design_after-effective_number_per_ite,number_design_after):
model = Surfpack(flag + '_' + str(ite), ndim_struct)
# model.load_data(os.path.join(build_points_folder,'build_points_' + flag + '.dat'))
exclude = []
for dsn_index in range(0, number_design_after):
design_folder = os.path.join(
project_folder, 'DESIGNS/DSN_%03d' % (dsn_index + 1))
history_file_name = os.path.join(
design_folder, 'STRUCTURE/history_structure.dat')
postpro_file_name = os.path.join(
design_folder, 'STRUCTURE/postpro_load_1.dat')
mass_file_name = os.path.join(
design_folder,
'STRUCTURE/lc0_mass_member.dat') # TO CHECK IF DONE INDEED
if os.path.exists(history_file_name) and os.path.exists(
postpro_file_name) and os.path.exists(mass_file_name):
history = np.loadtxt(history_file_name,
delimiter=',',
skiprows=1)
half_structure_mass = history[-1, 1]
local_config = SPACE.io.Config(
os.path.join(design_folder, 'config_DSN.cfg'))
local_dvs = pack_structure(local_config)
# ADD VALUE
check = history[-1, 2:5]
if (check[0] < threshold) and (check[1] < threshold) and (
check[2] < threshold):
if flag == 'STRUCTURE_MASS':
model.add(local_dvs, half_structure_mass)
elif flag == 'DRY_MASS':
raise ValueError(
'Do not use, not correctly defined')
else:
exclude.append(local_dvs)
print 'Warning:', dsn_index + 1
else:
print 'Missing:', dsn_index + 1
model.save_data(
os.path.join(build_points_folder,
'enriched_points_' + flag + '.dat'))
# Save Model
model.build('kriging')
model.save_model(os.path.join(project_folder,
'model_' + flag + '.sps'))
def load_aero_models():
n_models = 2180
models_folder = 'RESPONSE_SURFACE_DV_SUP/DESIGNS/MODELS'
for index in range(n_models):
cp_model = Surfpack('CP_%05d' % (index + 1), desvar.ndim)
cp_model.load_model(
os.path.join(models_folder, 'model_cp_%05d.sps' % (index + 1)))
for index in range(n_models):
cfx_model = Surfpack('CFX_%05d' % (index + 1), desvar.ndim)
cfx_model.load_model(
os.path.join(models_folder, 'model_cfx_%05d.sps' % (index + 1)))
for index in range(n_models):
cfy_model = Surfpack('CFY_%05d' % (index + 1), desvar.ndim)
cfy_model.load_model(
os.path.join(models_folder, 'model_cfy_%05d.sps' % (index + 1)))
for index in range(n_models):
cfz_model = Surfpack('CFZ_%05d' % (index + 1), desvar.ndim)
cfz_model.load_model(
os.path.join(models_folder, 'model_cfz_%05d.sps' % (index + 1)))