def copy_module_to_module(module_from, io_from, module_to, io_to):
""" Transfer CPACS file from one module to another.
Function 'copy_module_to_module' copy the CPACS file form ToolInput or
ToolOutput of 'module_from' to ToolInput or ToolOutput of 'module_to'
Args:
module_from (str): Name of the module the CPACS file is copy from
io_from (str): "in" or "out", for ToolInput or ToolOutput
module_to (str): Name of the module where the CPACS file will be copy
io_to (str): "in" or "out", for ToolInput or ToolOutput
"""
in_list = [
'in', 'In', 'IN', 'iN', 'input', 'Input', 'INPUT', 'ToolInput',
'toolinput'
]
if io_from in in_list:
file_copy_from = mi.get_toolinput_file_path(module_from)
else: # 'out' or anything else ('out' by default)
file_copy_from = mi.get_tooloutput_file_path(module_from)
log.info('Copy CPACS from:' + file_copy_from)
if io_to in in_list:
file_copy_to = mi.get_toolinput_file_path(module_to)
else: # 'out' or anything else ('out' by default)
file_copy_to = mi.get_tooloutput_file_path(module_to)
log.info('Copy CPACS to:' + file_copy_to)
shutil.copy(file_copy_from, file_copy_to)
def one_iteration():
"""
Compute the objective function.
Function 'one_iteration' will exectute in order all the module contained
in '...' and extract the ... value from the last CPACS file, this value will
be returned to the optimizer CPACSUpdater....
"""
global counter
counter += 1
# Create the parameter in CPACS with 'CPACSUpdater' module
cpacs_path = mi.get_toolinput_file_path('CPACSUpdater')
cpacs_out_path = mi.get_tooloutput_file_path('CPACSUpdater')
tixi = cpsf.open_tixi(cpacs_path)
wkdir_path = ceaf.create_new_wkdir(Rt.date)
WKDIR_XPATH = '/cpacs/toolspecific/CEASIOMpy/filesPath/wkdirPath'
tixi.updateTextElement(WKDIR_XPATH, wkdir_path)
# TODO: improve this part! (maybe move somewhere else)
# To delete coef from previous iter
if opf.get_aeromap_path(Rt.modules) != 'None':
xpath = opf.get_aeromap_path(Rt.modules)
aeromap_uid = cpsf.get_value(tixi, xpath + '/aeroMapUID')
Coef = apmf.get_aeromap(tixi, aeromap_uid)
apmf.delete_aeromap(tixi, aeromap_uid)
apmf.create_empty_aeromap(tixi, aeromap_uid, 'test_optim')
apmf.save_parameters(tixi, aeromap_uid, Coef)
cpsf.close_tixi(tixi, cpacs_path)
# Update the CPACS file with the parameters contained in design_var_dict
update_cpacs_file(cpacs_path, cpacs_out_path, design_var_dict)
# Save the CPACS file
if counter % 1 == 0:
file_copy_from = mi.get_tooloutput_file_path('CPACSUpdater')
shutil.copy(
file_copy_from,
optim_dir_path + '/Geometry/' + 'iter_{}.xml'.format(counter))
# Run optimisation sub workflow
wkf.copy_module_to_module('CPACSUpdater', 'out', Rt.modules[0], 'in')
wkf.run_subworkflow(Rt.modules)
wkf.copy_module_to_module(Rt.modules[-1], 'out', 'CPACSUpdater', 'in')
# Extract results TODO: improve this part
cpacs_results_path = mi.get_tooloutput_file_path(Rt.modules[-1])
log.info('Results will be extracted from:' + cpacs_results_path)
tixi = cpsf.open_tixi(cpacs_results_path)
# Update the constraints values
update_res_var_dict(tixi)
return compute_obj()
def compute(self, inputs, outputs):
"""Compute the objective expression"""
global counter
counter += 1
cpacs_path = mif.get_tooloutput_file_path(Rt.modules[-1])
# Save the CPACS file for this iteration
if counter % Rt.save_iter == 0:
loc = optim_dir_path + '/Geometry/' + 'iter_{}.xml'.format(counter)
shutil.copy(cpacs_path, loc)
# Add new variables to dictionnary
tixi = cpsf.open_tixi(cpacs_path)
dct.update_dict(tixi, optim_var_dict)
# Change local wkdir for the next iteration
tixi.updateTextElement(opf.WKDIR_XPATH,
ceaf.create_new_wkdir(Rt.date, Rt.type))
for obj in Rt.objective:
var_list = splt('[+*/-]', obj)
for v in var_list:
if not v.isdigit() and v != '':
exec('{} = inputs["{}"]'.format(v, v))
result = eval(obj)
if Rt.minmax == 'min':
outputs['Objective function ' + obj] = -result
else:
outputs['Objective function ' + obj] = result
cpsf.close_tixi(tixi, cpacs_path)
def compute(self, inputs, outputs):
"""Launches the module"""
# Updating inputs in CPACS file
cpacs_path = mif.get_toolinput_file_path(self.module_name)
tixi = cpsf.open_tixi(cpacs_path)
for name in inputs:
if name in optim_var_dict:
xpath = optim_var_dict[name][4]
cpsf.add_float_vector(tixi, xpath, inputs[name])
cpsf.close_tixi(tixi, cpacs_path)
# Running the module
wkf.run_subworkflow([self.module_name])
# Feeding CPACS file restults to outputs
cpacs_path = mif.get_tooloutput_file_path(self.module_name)
tixi = cpsf.open_tixi(cpacs_path)
for name in outputs:
if name in optim_var_dict:
xpath = optim_var_dict[name][4]
outputs[name] = cpsf.get_value(tixi, xpath)
# Copy CPACS to input folder of next module
index = Rt.modules.index(self.module_name) + 1
if index != len(Rt.modules):
cpacs_path = mif.get_toolinput_file_path(Rt.modules[index])
else:
cpacs_path = mif.get_toolinput_file_path(Rt.modules[0])
cpsf.close_tixi(tixi, cpacs_path)
def compute(self, inputs, outputs):
"""Update the geometry of the CPACS"""
cpacs_path = mif.get_tooloutput_file_path(Rt.modules[-1])
cpacs_path_out = mif.get_toolinput_file_path(Rt.modules[0])
for name, infos in geom_dict.items():
infos[1].append(inputs[name][0])
cpud.update_cpacs_file(cpacs_path, cpacs_path_out, geom_dict)
def compute(self, inputs, outputs):
"""Update the geometry of the CPACS"""
cpacs_path = mif.get_tooloutput_file_path(Rt.modules[-1])
cpacs_path_out = mif.get_toolinput_file_path(Rt.modules[0])
for name, (val_type, listval, minval, maxval, setcommand,
getcommand) in geom_dict.items():
listval.append(inputs[name][0])
cpud.update_cpacs_file(cpacs_path, cpacs_path_out, geom_dict)
def test_get_tooloutput_file_path():
"""
Test that 'get_tooloutput_file_path' works
"""
module_name = 'ModuleTemplate'
toolinput_path = m.get_tooloutput_file_path(module_name)
# Test that the end of the path is correct
assert toolinput_path.endswith(
os.path.join('CEASIOMpy', 'ceasiompy', 'ModuleTemplate', 'ToolOutput',
'ToolOutput.xml'))
def test_get_tooloutput_file_path():
"""
Test that 'get_tooloutput_file_path' works
"""
module_name = "ModuleTemplate"
toolinput_path = mi.get_tooloutput_file_path(module_name)
# Test that the end of the path is correct
assert toolinput_path.endswith(
os.path.join("CEASIOMpy", "ceasiompy", "ModuleTemplate", "ToolOutput",
"ToolOutput.xml"))
def compute(self, inputs, outputs):
"""Launches the module"""
# Updating inputs in CPACS file
cpacs_path = mif.get_toolinput_file_path(self.module_name)
tixi = cpsf.open_tixi(cpacs_path)
for name in inputs:
if name in optim_var_dict:
xpath = optim_var_dict[name][4]
# Change only the first vector value for aeromap param
if name in apmf.XSTATES:
size = tixi.getVectorSize(xpath)
v = list(tixi.getFloatVector(xpath, size))
v.pop(0)
v.insert(0, inputs[name])
tixi.updateFloatVector(xpath, v, size, '%g')
else:
cpsf.add_float_vector(tixi, xpath, inputs[name])
cpsf.close_tixi(tixi, cpacs_path)
# Running the module
wkf.run_subworkflow([self.module_name])
# Feeding CPACS file results to outputs
cpacs_path = mif.get_tooloutput_file_path(self.module_name)
tixi = cpsf.open_tixi(cpacs_path)
for name in outputs:
if name in optim_var_dict:
xpath = optim_var_dict[name][4]
if name in apmf.COEF_LIST:
val = cpsf.get_value(tixi, xpath)
if isinstance(val, str):
val = val.split(';')
outputs[name] = val[0]
else:
outputs[name] = val
else:
outputs[name] = cpsf.get_value(tixi, xpath)
# Copy CPACS to input folder of next module
index = Rt.modules.index(self.module_name) + 1
if index != len(Rt.modules):
cpacs_path = mif.get_toolinput_file_path(Rt.modules[index])
else:
cpacs_path = mif.get_toolinput_file_path(Rt.modules[0])
cpsf.close_tixi(tixi, cpacs_path)
def compute(self, inputs, outputs):
"""Make a prediction"""
xp = []
for name in self.xd.index:
xp.append(inputs[name][0])
xp = np.array([xp])
yp = self.Model.sm.predict_values(xp)
for i, name in enumerate(self.yd.index):
outputs[name] = yp[0][i]
# Write the inouts to the CPACS
cpacs_path = mif.get_toolinput_file_path('SMUse')
tixi = cpsf.open_tixi(cpacs_path)
smu.write_inouts(self.xd, xp, tixi)
smu.write_inouts(self.yd, yp, tixi)
cpacs_path_out = mif.get_tooloutput_file_path('SMUse')
cpsf.close_tixi(tixi, cpacs_path_out)
def save_model(Tool):
"""Save trained surrogate model to a file.
Create a file to which the class containing the surrogate model and its
parameters will be saved in order to be re-used using the pickle module.
The file is saved in the current working directory and the path to it is
added to the CPACS file.
Args:
Tool (Prediction_tool object): Contains the model
Returns:
None.
"""
date = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
cpacs_path = mif.get_toolinput_file_path('SMTrain')
cpacs_out_path = mif.get_tooloutput_file_path('SMTrain')
tixi = cpsf.open_tixi(cpacs_path)
filename = Tool.wkdir + '/Surrogate_Model_' + date
cpsf.create_branch(tixi, SMFILE_XPATH)
tixi.updateTextElement(SMFILE_XPATH, filename)
cpsf.close_tixi(tixi, cpacs_out_path)
Tool.df.to_csv(Tool.wkdir + '/Data_setup.csv', index=False, na_rep='-')
Model = Surrogate_model()
Model.df = Tool.df
Model.sm = Tool.sm
sm_file = open(filename, 'wb')
pickle.dump(Model, sm_file)
# MAIN
# ==============================================================================
def main(cpacs_path, cpacs_out_path):
log.info("----- Start of " + os.path.basename(__file__) + " -----")
# Load the model
cpacs = CPACS(cpacs_path)
Model = load_surrogate(cpacs.tixi)
check_aeromap(cpacs.tixi)
if get_value_or_default(cpacs.tixi, SMUSE_XPATH + "/AeroMapOnly", False):
aeromap_calculation(Model.sm, cpacs)
else:
predict_output(Model, cpacs)
cpacs.save_cpacs(cpacs_out_path, overwrite=True)
log.info("----- End of " + os.path.basename(__file__) + " -----")
if __name__ == "__main__":
cpacs_path = mi.get_toolinput_file_path("SMUse")
cpacs_out_path = mi.get_tooloutput_file_path("SMUse")
main(cpacs_path, cpacs_out_path)
def one_optim_iter():
"""Function to evaluate the value to optimize.
Function 'one_optim_iter' will exectute in order all the module contained
in '...' and extract the ... value from the last CPACS file, this value will
be returned to the optimizer
CPACSUpdater....
"""
# Create the parameter in CPACS with 'CPACSUpdater' module
cpacs_path = mi.get_toolinput_file_path('CPACSUpdater')
cpacs_out_path = mi.get_tooloutput_file_path('CPACSUpdater')
tixi = cpsf.open_tixi(cpacs_path)
wkdir_path = ceaf.create_new_wkdir()
WKDIR_XPATH = '/cpacs/toolspecific/CEASIOMpy/filesPath/wkdirPath'
tixi.updateTextElement(WKDIR_XPATH, wkdir_path)
# TODO: improve this part! (maybe move somewhere else)
# To delete coef from previous iter
aeromap_uid = cpsf.get_value(tixi, SU2_XPATH + '/aeroMapUID')
Coef = apmf.get_aeromap(tixi, aeromap_uid)
apmf.delete_aeromap(tixi, aeromap_uid)
apmf.create_empty_aeromap(tixi, aeromap_uid, 'test_optim')
apmf.save_parameters(tixi, aeromap_uid, Coef)
cpsf.close_tixi(tixi, cpacs_path)
# Update the CPACS file with the parameters contained in optim_var_dict
update_cpacs_file(cpacs_path, cpacs_out_path, optim_var_dict)
# Run optimisation sub workflow
wkf.copy_module_to_module('CPACSUpdater', 'out', module_optim[0], 'in')
wkf.run_subworkflow(module_optim)
wkf.copy_module_to_module(module_optim[-1], 'out', 'CPACSUpdater', 'in')
# Extract results TODO: improve this part
cpacs_results_path = mi.get_tooloutput_file_path(module_optim[-1])
log.info('Results will be extracted from:' + cpacs_results_path)
tixi = cpsf.open_tixi(cpacs_results_path)
mtom = cpsf.get_value(
tixi,
'/cpacs/vehicles/aircraft/model/analyses/massBreakdown/designMasses/mTOM/mass'
)
aeromap_uid = cpsf.get_value(tixi, SU2_XPATH + '/aeroMapUID')
Coef = apmf.get_aeromap(tixi, aeromap_uid)
cl = Coef.cl[0]
cd = Coef.cd[0]
cm = Coef.cms[0]
log.info('=========================')
for key, (name, listval, minval, maxval,
command) in optim_var_dict.items():
log.info(name, ': ', listval[-1])
log.info('Cl/Cd: ' + str(cl / cd))
log.info('Cl: ' + str(cl))
log.info('Cd: ' + str(cd))
log.info('Cd: ' + str(cm))
log.info('MTOM:' + str(mtom))
log.info('(Cl)/MTOM:' + str(cl / mtom))
log.info('=========================')
# TODO: add option to choose what will be returned
# return -mtom
# return -cl
# return cd
# return -cl/cd
return -cl / cd / mtom
def run_subworkflow(module_to_run, cpacs_path_in='', cpacs_path_out=''):
"""Function to run a list of module in order.
Function 'run_subworkflow' will exectute in order all the module contained
in 'module_to_run' list. Every time the resuts of one module (generaly CPACS
file) will be copied as input for the next module.
Args:
module_to_run (list): List of mododule to run (in order)
cpacs_path_in (str): Path of the CPACS file use, if not already in the
ToolInput folder of the first submodule
cpacs_path_out (str): Path of the output CPACS file use, if not already
in the ToolInput folder of the first submodule
"""
if not module_to_run:
log.info('No module to run')
return 0
# Check non existing module
submodule_list = mi.get_submodule_list()
for module in module_to_run:
if module not in submodule_list:
raise ValueError('No module named "' + module + '"!')
# Copy the cpacs file in the first module
if cpacs_path_in:
shutil.copy(cpacs_path_in,
mi.get_toolinput_file_path(module_to_run[0]))
log.info('The following modules will be executed: ')
for module in module_to_run:
log.info(module)
for m, module in enumerate(module_to_run):
log.info(
'######################################################################################'
)
log.info('Run module: ' + module)
log.info(
'######################################################################################'
)
# Go to the module directory
module_path = os.path.join(LIB_DIR, module)
log.info('Going to ' + module_path)
os.chdir(module_path)
# Copy CPACS file from previous module to this one
if m > 0:
copy_module_to_module(module_to_run[m - 1], 'out', module, 'in')
if module == 'SettingsGUI':
cpacs_path = mi.get_toolinput_file_path(module)
cpacs_out_path = mi.get_tooloutput_file_path(module)
# Check if there is at least one other 'SettingsGUI' after this one
if 'SettingsGUI' in module_to_run[m + 1:] and m + 1 != len(
module_to_run):
idx = module_to_run.index('SettingsGUI', m + 1)
create_settings_gui(cpacs_path, cpacs_out_path,
module_to_run[m:idx])
else:
create_settings_gui(cpacs_path, cpacs_out_path,
module_to_run[m:])
else:
# Find the python file to run
for file in os.listdir(module_path):
if file.endswith('.py'):
if not file.startswith('__'):
main_python = file
# Run the module
error = subprocess.call(['python', main_python])
if error:
raise ValueError('An error ocured in the module ' + module)
# Copy the cpacs file in the first module
if cpacs_path_out:
shutil.copy(mi.get_tooloutput_file_path(module_to_run[-1]),
cpacs_path_out)
import ceasiompy.CPACSUpdater.cpacsupdater as cpud
from ceasiompy.utils.ceasiomlogger import get_logger
log = get_logger(__file__.split('.')[0])
# =============================================================================
# GLOBALS
# =============================================================================
MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
MODULE_NAME = os.path.basename(os.getcwd())
SMUSE_XPATH = '/cpacs/toolspecific/CEASIOMpy/surrogateModelUse/'
SMTRAIN_XPATH = '/cpacs/toolspecific/CEASIOMpy/surrogateModel/'
cpacs_path = mif.get_toolinput_file_path('SMUse')
cpacs_path_out = mif.get_tooloutput_file_path('SMUse')
# =============================================================================
# ClASSES
# =============================================================================
class Surrogate_model():
"""Class to be dumped for later use of a model"""
def __init__(self):
"""Creates main components"""
# The dataframe that contains the ordered list of variables to be given
# to this model, as well as their respective XPATH.
self.data = pd.DataFrame()
# The trained surrogate model object
self.sm = sms.surrogate_model.SurrogateModel()
create_om_problem(prob)
## Run the model ##
prob.run_driver()
generate_results(prob)
if __name__ == '__main__':
log.info('----- Start of ' + os.path.basename(__file__) + ' -----')
log.info('Impose the aeromap of the optimisation to all other modules')
cpacs_path = mif.get_toolinput_file_path('Optimisation')
cpacs_out_path = mif.get_tooloutput_file_path('Optimisation')
tixi = cpsf.open_tixi(cpacs_path)
try:
am_uid = cpsf.get_value(tixi, opf.OPTIM_XPATH + 'aeroMapUID')
except:
raise ValueError('No aeromap found in the file')
log.info('Aeromap ' + am_uid + ' will be used')
#opf.update_am_path(tixi, am_uid)
cpsf.close_tixi(tixi, cpacs_out_path)
log.info('----- End of ' + os.path.basename(__file__) + ' -----')
def aeromap_case_gen(modules):
"""
Generate a CSV file containing a dataset generated with aeromap parameters
only.
Args:
modules (lst) : list of modules to execute.
Returns:
file (str) : Path to CSV file.
"""
file = MODULE_DIR + '/Aeromap_generated.csv'
infile = mi.get_toolinput_file_path('PredictiveTool')
outfile = mi.get_tooloutput_file_path('PredictiveTool')
tixi = cpsf.open_tixi(infile)
# Inputs
alt = [0, 0]
mach = [0.5, 0.5]
aoa = [-10, 10]
aos = [0, 0]
nt = 100
bounds = np.array([alt, mach, aoa, aos])
# Sort criterion : ‘center’, ‘maximin’, ‘centermaximin’, ‘correlation’
crit = 'corr'
# Generate sample points, LHS or FullFactorial
sampling = smp.LHS(xlimits=bounds, criterion=crit)
xd = sampling(nt)
xd = xd.transpose()
# Delete the other aeromaps... maybe conserve them ?
for uid in apmf.get_aeromap_uid_list(tixi):
apmf.delete_aeromap(tixi, uid)
# Create new aeromap
aeromap_uid = 'DoE_Aeromap'
am_xpath = tls.get_aeromap_path(modules)
apmf.create_empty_aeromap(tixi, aeromap_uid)
cpsf.add_string_vector(tixi, am_xpath + '/aeroMapUID', [aeromap_uid])
# Add parameters to aeromap
Param = apmf.AeroCoefficient()
for i in range(0, xd.shape[1]):
Param.add_param_point(xd[0][i], xd[1][i], xd[2][i], xd[3][i])
apmf.save_parameters(tixi, aeromap_uid, Param)
cpsf.close_tixi(tixi, infile)
wkf.run_subworkflow(modules, cpacs_path_in=infile, cpacs_path_out=outfile)
# Get Aerocoefficient
tixi = cpsf.open_tixi(outfile)
am_xpath = tls.get_aeromap_path(modules)
aeromap_uid = cpsf.get_value(tixi, am_xpath + '/aeroMapUID')
AeroCoefficient = apmf.get_aeromap(tixi, aeromap_uid)
cpsf.close_tixi(tixi, outfile)
dct = AeroCoefficient.to_dict()
# Write to CSV
df = pd.DataFrame(dct)
df = df.transpose()
var_type = [
'obj' if i in objectives else
'des' if i in ['alt', 'mach', 'aoa', 'aos'] else 'const'
for i in df.index
]
df.insert(0, 'type', var_type)
df.to_csv(file, index=True)
return file
root.geometry('475x495+400+300')
my_gui = WorkFlowGUI()
my_gui.mainloop()
disg = my_gui.Options
root.iconify() # Not super solution but only way to make it close on Mac
root.destroy()
return disg
if __name__ == '__main__':
log.info('----- Start of ' + os.path.basename(__file__) + ' -----')
cpacs_path_out = mi.get_tooloutput_file_path(MODULE_NAME)
gui = False
if len(sys.argv) > 1:
if sys.argv[1] == '-gui':
gui = True
else:
print(' ')
print('Not valid argument!')
print(
'You can use the option -gui to run this module with a user interface.'
)
print(' ')
sys.exit()
def run_workflow(Otp):
""" Run the complete Worflow
Args:
Opt (class): Cl
cpacs_out_path (str): Path to the output CPACS file
module_list (list): List of module to inclue in the GUI
"""
# Copy ToolInput.xml in ToolInput dir if not already there
cpacs_path = mi.get_toolinput_file_path(MODULE_NAME)
if not os.path.abspath(Opt.cpacs_path) == os.path.abspath(cpacs_path):
shutil.copy(Opt.cpacs_path, cpacs_path)
Opt.cpacs_path = os.path.abspath(cpacs_path)
# Create a new wkdir
tixi = cpsf.open_tixi(Opt.cpacs_path)
wkdir = ceaf.get_wkdir_or_create_new(tixi)
cpsf.close_tixi(tixi, Opt.cpacs_path)
# Run Pre-otimisation workflow
if Opt.module_pre:
wkf.run_subworkflow(Opt.module_pre, Opt.cpacs_path)
if not Opt.module_optim and not Opt.module_post:
shutil.copy(mi.get_tooloutput_file_path(Opt.module_pre[-1]),
cpacs_path_out)
# Run Optimisation workflow
if Opt.module_optim:
if Opt.module_pre:
wkf.copy_module_to_module(Opt.module_pre[-1], 'out',
'Optimisation', 'in')
else:
wkf.copy_module_to_module('WorkflowCreator', 'in', 'Optimisation',
'in')
if Opt.optim_method != 'None':
routine_launcher(Opt)
else:
log.warning('No optimization method has been selected!')
log.warning('The modules will be run as a simple workflow')
wkf.run_subworkflow(Opt.module_optim)
if not Opt.module_post:
shutil.copy(mi.get_tooloutput_file_path(Opt.module_optim[-1]),
cpacs_path_out)
# Run Post-optimisation workflow
if Opt.module_post:
if Opt.module_optim:
wkf.copy_module_to_module(Opt.module_optim[-1], 'out',
Opt.module_post[0], 'in')
elif Opt.module_pre:
wkf.copy_module_to_module(Opt.module_pre[-1], 'out',
Opt.module_post[0], 'in')
else:
wkf.copy_module_to_module('WorkflowCreator', 'in',
Opt.module_post[0], 'in')
# wkf.copy_module_to_module('CPACSUpdater','out',Opt.module_post[0],'in') usefuel?
wkf.run_subworkflow(Opt.module_post)
shutil.copy(mi.get_tooloutput_file_path(Opt.module_post[-1]),
cpacs_path_out)
axs[0, 2].plot(grp['cd'], grp['cl'], 'x-')
axs[1, 2].plot(grp['cl'], grp['cl'] / grp['cd'], 'x-')
# Set subplot options
subplot_options(axs[0, 0], 'CL', 'AoA')
subplot_options(axs[1, 0], 'CD', 'AoA')
subplot_options(axs[0, 1], 'Cm', 'AoA')
subplot_options(axs[1, 1], 'CL/CD', 'AoA')
subplot_options(axs[0, 2], 'CL', 'CD')
subplot_options(axs[1, 2], 'CL/CD', 'CL')
fig.legend(loc='upper right')
plt.show()
#==============================================================================
# MAIN
#==============================================================================
if __name__ == '__main__':
log.info('----- Start of ' + os.path.basename(__file__) + ' -----')
MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
cpacs_path = mi.get_toolinput_file_path(MODULE_NAME)
cpacs_out_path = mi.get_tooloutput_file_path(MODULE_NAME)
plot_aero_coef(cpacs_path, cpacs_out_path)
log.info('----- End of ' + os.path.basename(__file__) + ' -----')
def main():
log.info("Running PyTornado...")
# ===== CPACS inout and output paths =====
MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
cpacs_in_path = mi.get_toolinput_file_path(MODULE_NAME)
cpacs_out_path = mi.get_tooloutput_file_path(MODULE_NAME)
# ===== Delete old working directories =====
settings_from_CPACS = get_pytornado_settings_from_CPACS(cpacs_in_path)
if settings_from_CPACS is not None:
if settings_from_CPACS.get('deleteOldWKDIRs', False):
wkdirs = glob(os.path.join(DIR_MODULE, 'wkdir_*'))
for wkdir in wkdirs:
shutil.rmtree(wkdir, ignore_errors=True)
# ===== Paths =====
dir_pyt_wkdir = os.path.join(DIR_MODULE, 'wkdir_temp')
dir_pyt_aircraft = os.path.join(dir_pyt_wkdir, 'aircraft')
dir_pyt_settings = os.path.join(dir_pyt_wkdir, 'settings')
dir_pyt_results = os.path.join(dir_pyt_wkdir, '_results')
file_pyt_aircraft = os.path.join(dir_pyt_aircraft, 'ToolInput.xml')
file_pyt_settings = os.path.join(dir_pyt_settings, 'cpacs_run.json')
# ===== Make directories =====
Path(dir_pyt_wkdir).mkdir(parents=True, exist_ok=True)
Path(dir_pyt_aircraft).mkdir(parents=True, exist_ok=True)
Path(dir_pyt_settings).mkdir(parents=True, exist_ok=True)
Path(dir_pyt_results).mkdir(parents=True, exist_ok=True)
# ===== Setup =====
shutil.copy(src=cpacs_in_path, dst=file_pyt_aircraft)
mi.check_cpacs_input_requirements(cpacs_in_path)
# ===== Get PyTornado settings =====
cpacs_settings = get_pytornado_settings(cpacs_in_path)
with open(file_pyt_settings, "w") as fp:
dump_pretty_json(cpacs_settings, fp)
# ===== PyTornado analysis =====
pytornado = import_pytornado('pytornado.stdfun.run')
#pytornado.standard_run(args=pytornado.StdRunArgs(run=file_pyt_settings, verbose=True))
results = pytornado.standard_run(
args=pytornado.StdRunArgs(run=file_pyt_settings, verbose=True))
# ===== Extract load =====
tixi = cpsf.open_tixi(cpacs_in_path)
extract_loads_xpath = '/cpacs/toolspecific/pytornado/save_results/extractLoads'
extract_loads = cpsf.get_value_or_default(tixi, extract_loads_xpath, False)
if extract_loads:
_get_load_fields(results, dir_pyt_results)
# ===== Clean up =====
shutil.copy(src=file_pyt_aircraft, dst=cpacs_out_path)
wkdir = ceaf.get_wkdir_or_create_new(tixi)
dst_pyt_wkdir = os.path.join(
wkdir, 'CFD', 'PyTornado',
f"wkdir_{datetime.strftime(datetime.now(), '%F_%H%M%S')}")
shutil.copytree(src=dir_pyt_wkdir, dst=dst_pyt_wkdir)
shutil.rmtree(dir_pyt_wkdir, ignore_errors=True)
log.info("PyTornado analysis completed")
