def check_length(self): # Load the current sqlitedict cr = self.case_reader = SqliteCaseReader(self.db_name) # Get the number of current iterations # Minus one because OpenMDAO uses 1-indexing self.num_iters = int(cr.driver_cases.list_cases()[-1].split('|')[-1])
def check_length(self): # Load the current sqlitedict cr = self.case_reader = SqliteCaseReader(self.db_name) # Get the number of current iterations # Minus one because OpenMDAO uses 1-indexing self.num_iters = len(cr.get_cases('driver'))
def CaseReader(filename): """ A factory function that returns a CaseReader for the given file. Parameters ---------- filename : str A path to the recorded file. The file should have been recorded using either the SqliteRecorder or the HDF5Recorder. Returns ------- An instance of SqliteCaseReader or HDF5CaseReader, depending on the contents of the given file. """ try: reader = SqliteCaseReader(filename) return reader except IOError: # filename not a valid Sqlite database file pass try: reader = HDF5CaseReader(filename) return reader except IOError: raise IOError('Unable to load cases from file {0}'.format(filename))
def CaseReader(filename): """ Return a CaseReader for the given file. Parameters ---------- filename : str A path to the recorded file. The file should have been recorded using either the SqliteRecorder or the HDF5Recorder. Returns ------- reader : BaseCaseReader An instance of a SqliteCaseReader that is reading filename. """ reader = SqliteCaseReader(filename) return reader
def upload(sqlite_file, token, name=None, case_id=None, suppress_output=False): """ Upload sqlite recording to the web server. Parameters ---------- sqlite_file : str The location of the sqlite file. token : str The web recorder token. name : str The name of the recording (defaults to None). case_id : str The case_id if this upload is intended to update a recording. suppress_output : bool Indicates whether or not the upload status should be printed. """ reader = SqliteCaseReader(sqlite_file) if case_id is None: recorder = WebRecorder(token, name) else: recorder = WebRecorder(token, name, case_id=case_id) if not suppress_output: print('Data Uploader: Recording metadata') _upload_metadata(reader._abs2prom, reader._prom2abs, recorder) if not suppress_output: print('Data Uploader: Recording driver iteration data') _upload_driver_iterations(reader.driver_cases, recorder) if not suppress_output: print('Data Uploader: Recording system iteration data') _upload_system_iterations(reader.system_cases, recorder) if not suppress_output: print('Data Uploader: Recording solver iteration data') _upload_solver_iterations(reader.solver_cases, recorder) recorder._record_driver_metadata('Driver', json.dumps(reader.driver_metadata)) for item in reader.solver_metadata: recorder._record_solver_metadata(reader.solver_metadata[item]['solver_options'], reader.solver_metadata[item]['solver_class'], '') if not suppress_output: print('Finished uploading')
def CaseReader(filename, pre_load=True): """ Return a CaseReader for the given file. Parameters ---------- filename : str A path to the recorded file. Currently only sqlite database files recorded via SqliteRecorder are supported. pre_load : bool If True, load all the data into memory during initialization. Returns ------- reader : BaseCaseReader An instance of a CaseReader. """ return SqliteCaseReader(filename, pre_load)
def CaseReader(filename): """ Return a CaseReader for the given file. Parameters ---------- filename : str A path to the recorded file. The file should have been recorded using either the SqliteRecorder or the HDF5Recorder. Returns ------- An instance of SqliteCaseReader. """ try: reader = SqliteCaseReader(filename) return reader except IOError: # filename not a valid Sqlite database file raise IOError('Unable to load cases from file {0}'.format(filename))
def CaseReader(filename, pre_load=True, metadata_filename=None): """ Return a CaseReader for the given file. Parameters ---------- filename : str A path to the recorded file. Currently only sqlite database files recorded via SqliteRecorder are supported. pre_load : bool If True, load all the data into memory during initialization. metadata_filename : str For separate metadata from parallel runs, the metadata database filename. Returns ------- BaseCaseReader An instance of a CaseReader. """ return SqliteCaseReader(filename, pre_load, metadata_filename)
def load_db(self): cr = self.case_reader = SqliteCaseReader(self.db_name, pre_load=True) last_case = next(reversed(cr.get_cases('driver'))) names = [] # Aero or aerostructural for key in cr.system_metadata.keys(): try: surfaces = cr.system_metadata[key]['component_options'][ 'surfaces'] for surface in surfaces: names.append(surface['name']) break except: pass # Structural-only if not names: for key in cr.system_metadata.keys(): try: surface = cr.system_metadata[key]['component_options'][ 'surface'] names = [surface['name']] except: pass # figure out if this is an optimization and what the objective is obj_keys = last_case.get_objectives() if obj_keys.keys(): # if its not an empty list self.opt = True self.obj_key = list(obj_keys.keys())[0] else: self.opt = False self.twist = [] self.mesh = [] self.def_mesh = [] self.radius = [] self.thickness = [] sec_forces = [] normals = [] widths = [] self.lift = [] self.lift_ell = [] self.vonmises = [] alpha = [] rho = [] v = [] self.CL = [] self.AR = [] self.S_ref = [] self.obj = [] self.cg = [] self.point_mass_locations = [] pt_names = [] for key in last_case.outputs: if 'coupled' in key: self.aerostruct = True for key in last_case.outputs: if 'CL' in key: pt_names.append(key.split('.')[0]) break if pt_names: self.pt_names = pt_names = list(set(pt_names)) pt_name = pt_names[0] else: pt_names = [''] self.names = names n_names = len(names) # loop to pull data out of case reader and organize it into arrays for i, case in enumerate(cr.get_cases()): if self.opt: self.obj.append(case.outputs[self.obj_key]) # Loop through each of the surfaces for name in names: # Check if this is an aerostructual case; treat differently # due to the way the problem is organized if not self.aerostruct: # A mesh exists for all types of cases self.mesh.append(case.outputs[name + '.mesh']) try: self.radius.append( np.squeeze(case.outputs[name + '.radius'])) self.thickness.append(case.outputs[name + '.thickness']) self.vonmises.append( np.max(case.outputs[name + '.vonmises'], axis=1)) self.show_tube = True except: self.show_tube = False
def load_db(self): cr = self.case_reader = SqliteCaseReader(self.db_name, pre_load=True) last_case = next(reversed(cr.get_cases('driver'))) names = [] for key in cr.system_metadata.keys(): try: surfaces = cr.system_metadata[key]['component_options'][ 'surfaces'] for surface in surfaces: names.append(surface['name']) break except: pass # figure out if this is an optimization and what the objective is obj_keys = last_case.get_objectives() if obj_keys.keys(): # if its not an empty list self.opt = True self.obj_key = list(obj_keys.keys())[0] else: self.opt = False self.twist = [] self.mesh = [] self.def_mesh = [] self.def_mesh_maneuver = [] self.radius = [] self.spar_thickness = [] self.skin_thickness = [] self.t_over_c = [] sec_forces = [] sec_forces_maneuver = [] normals = [] normals_maneuver = [] widths = [] widths_maneuver = [] self.lift = [] self.lift_ell = [] self.lift_maneuver = [] self.lift_ell_maneuver = [] self.vonmises = [] alpha = [] alpha_maneuver = [] rho = [] rho_maneuver = [] v = [] self.CL = [] self.AR = [] self.S_ref = [] self.obj = [] self.struct_masses = [] self.cg = [] self.point_mass_locations = [] # find the names of all surfaces pt_names = [] for key in last_case.outputs: # Aerostructural if 'coupled' in key: self.aerostruct = True if 'loads' in key: pt_names.append(key.split('.')[0]) # This logic isn't guaranteed to always be in the same order. # Hardcoding for now because this script is already non-general. # if pt_names: # self.pt_names = pt_names = list(set(pt_names)) # pt_name = pt_names[0] self.pt_names = pt_names = ['AS_point_0', 'AS_point_1'] pt_name = self.pt_names[0] self.names = names n_names = len(names) # loop to pull data out of case reader and organize it into arrays for i, case in enumerate(cr.get_cases()): if self.opt: self.obj.append(case.outputs[self.obj_key]) # Loop through each of the surfaces for name in names: # Check if this is an aerostructual case; treat differently # due to the way the problem is organized if not self.aerostruct: # A mesh exists for all types of cases self.mesh.append(case.outputs[name + '.mesh']) try: self.radius.append( np.squeeze(case.outputs[name + '.radius'])) self.thickness.append(case.outputs[name + '.thickness']) self.vonmises.append( np.max(case.outputs[name + '.vonmises'], axis=1)) self.show_tube = True except: self.show_tube = False
def load_db(self): cr = self.case_reader = SqliteCaseReader(self.db_name) cr.load_cases() last_case = cr.driver_cases.get_case(-1) # figure out if this is an optimization and what the objective is obj_keys = last_case.get_objectives() try: # if its not an empty list self.obj_key = obj_keys.keys[0] self.opt = True except IndexError: self.opt = False self.twist = [] self.mesh = [] self.def_mesh = [] self.radius = [] self.thickness = [] sec_forces = [] normals = [] widths = [] self.lift = [] self.lift_ell = [] self.vonmises = [] alpha = [] rho = [] v = [] self.CL = [] self.AR = [] self.S_ref = [] self.obj = [] self.cg = [] # find the names of all surfaces names = [] pt_names = [] for key in last_case.outputs: # Aerostructural if 'coupled' in key and 'loads' in key: self.aerostruct = True # convoluted way to get the surface name from `<point_name>.coupled.<surf_name>_loads` surf_name = (key.split('.')[2]).split("_")[0] names.append(surf_name) # Aero only elif 'sec_forces' in key and 'coupled' not in key: surf_name = (key.split('.')[2]).split("_")[0] names.append(surf_name) # Structural only elif 'disp_aug' in key and 'coupled' not in key: surf_name = key.split('.')[0] names.append(surf_name) if 'CL' in key: pt_names.append(key.split('.')[0]) if pt_names: self.pt_names = pt_names = list(set(pt_names)) pt_name = pt_names[0] self.names = names n_names = len(names) # loop to pull data out of case reader and organize it into arrays for i, case in enumerate(cr.get_cases()): if self.opt: self.obj.append(case.outputs[self.obj_key]) # Loop through each of the surfaces for name in names: # Check if this is an aerostructual case; treat differently # due to the way the problem is organized if not self.aerostruct: # A mesh exists for all types of cases self.mesh.append(case.outputs[name+'.mesh']) try: self.radius.append(case.outputs[name+'.radius']) self.thickness.append(case.outputs[name+'.thickness']) self.vonmises.append( np.max(case.outputs[name+'.vonmises'], axis=1)) self.show_tube = True except: self.show_tube = False
def read_db(db_name): output_dict = {} cr = SqliteCaseReader(db_name, pre_load=True) last_case = next(reversed(cr.get_cases('driver'))) names = [] for key in cr.system_metadata.keys(): try: surfaces = cr.system_metadata[key]['component_options']['surfaces'] for surface in surfaces: names.append(surface['name']) break except: pass obj_keys = last_case.get_objectives() output_dict['opt'] = True obj_key = list(obj_keys.keys())[0] output_dict['twist'] = [] output_dict['mesh'] = [] output_dict['def_mesh'] = [] output_dict['def_mesh_maneuver'] = [] output_dict['spar_thickness'] = [] output_dict['skin_thickness'] = [] output_dict['t_over_c'] = [] sec_forces = [] sec_forces_maneuver = [] normals = [] normals_maneuver = [] widths = [] widths_maneuver = [] output_dict['lift'] = [] output_dict['lift_ell'] = [] output_dict['lift_maneuver'] = [] output_dict['lift_ell_maneuver'] = [] output_dict['lift_ell_span'] = [] output_dict['vonmises'] = [] alpha_maneuver = [] rho = [] rho_maneuver = [] output_dict['alpha'] = [] output_dict['v'] = [] output_dict['CL'] = [] output_dict['CD'] = [] output_dict['AR'] = [] output_dict['S_ref'] = [] output_dict['obj'] = [] output_dict['struct_masses'] = [] output_dict['cg'] = [] output_dict['point_mass_locations'] = [] output_dict['total_weight'] = [] pt_names = ['AS_point_0', 'AS_point_1'] pt_name = pt_names[0] n_names = len(names) # loop to pull data out of case reader and organize it into arrays for i, case in enumerate(cr.get_cases()): output_dict['obj'].append(case.outputs[obj_key]) # Loop through each of the surfaces for name in names: output_dict['mesh'].append(case.outputs[name + '.mesh']) output_dict['skin_thickness'].append( case.outputs[name + '.skin_thickness']) output_dict['spar_thickness'].append( case.outputs[name + '.spar_thickness']) output_dict['t_over_c'].append(case.outputs[name + '.t_over_c']) output_dict['struct_masses'].append( case.outputs[name + '.structural_mass']) vm_var_name = '{pt_name}.{surf_name}_perf.vonmises'.format( pt_name=pt_names[1], surf_name=name) output_dict['vonmises'].append( np.max(case.outputs[vm_var_name], axis=1)) def_mesh_var_name = '{pt_name}.coupled.{surf_name}.def_mesh'.format( pt_name=pt_name, surf_name=name) output_dict['def_mesh'].append(case.outputs[def_mesh_var_name]) def_mesh_var_name = '{pt_name}.coupled.{surf_name}.def_mesh'.format( pt_name=pt_names[1], surf_name=name) output_dict['def_mesh_maneuver'].append( case.outputs[def_mesh_var_name]) normals_var_name = '{pt_name}.coupled.{surf_name}.normals'.format( pt_name=pt_name, surf_name=name) normals.append(case.outputs[normals_var_name]) normals_var_name = '{pt_name}.coupled.{surf_name}.normals'.format( pt_name=pt_names[1], surf_name=name) normals_maneuver.append(case.outputs[normals_var_name]) widths_var_name = '{pt_name}.coupled.{surf_name}.widths'.format( pt_name=pt_name, surf_name=name) widths.append(case.outputs[widths_var_name]) widths_var_name = '{pt_name}.coupled.{surf_name}.widths'.format( pt_name=pt_names[1], surf_name=name) widths_maneuver.append(case.outputs[widths_var_name]) sec_forces.append(case.outputs[pt_name + '.coupled.aero_states.' + name + '_sec_forces']) sec_forces_maneuver.append( case.outputs[pt_names[1] + '.coupled.aero_states.' + name + '_sec_forces']) cl_var_name = '{pt_name}.{surf_name}_perf.CL1'.format( pt_name=pt_name, surf_name=name) output_dict['CL'].append(case.outputs[cl_var_name]) cd_var_name = '{pt_name}.CD'.format(pt_name=pt_name) output_dict['CD'].append(case.outputs[cd_var_name]) S_ref_var_name = '{pt_name}.coupled.{surf_name}.aero_geom.S_ref'.format( pt_name=pt_name, surf_name=name) output_dict['S_ref'].append(case.outputs[S_ref_var_name]) output_dict['twist'].append(case.outputs[name + '.geometry.twist'])