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