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