def initialise(self, in_dict):
self.settings = in_dict
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
if self.settings['span_with_gust'].value == 0:
self.settings['span_with_gust'] = self.settings['span']
def initialise(self, data, input_dict=None):
self.data = data
if input_dict is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = input_dict
settings.to_custom_types(self.settings,
self.settings_types,
self.settings_default,
options=self.settings_options)
self.structural_solver = solver_interface.initialise_solver(
self.settings['structural_solver'])
self.structural_solver.initialise(
self.data, self.settings['structural_solver_settings'])
self.aero_solver = solver_interface.initialise_solver(
self.settings['aero_solver'])
self.aero_solver.initialise(self.structural_solver.data,
self.settings['aero_solver_settings'])
self.data = self.aero_solver.data
# load info from dyn dictionary
self.data.structure.add_unsteady_information(
self.data.structure.dyn_dict, 1)
# Define the function to correct aerodynamic forces
if self.settings['correct_forces_method'] is not '':
self.correct_forces = True
self.correct_forces_function = cf.dict_of_corrections[
self.settings['correct_forces_method']]
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
self.dt = self.settings['dt']
self.print_info = self.settings['print_info'].value
self.aero_solver = solver_interface.initialise_solver(
self.settings['aero_solver'])
self.aero_solver.initialise(self.data,
self.settings['aero_solver_settings'])
self.data = self.aero_solver.data
# initialise postprocessors
self.postprocessors = dict()
if len(self.settings['postprocessors']) > 0:
self.with_postprocessors = True
for postproc in self.settings['postprocessors']:
self.postprocessors[postproc] = solver_interface.initialise_solver(
postproc)
self.postprocessors[postproc].initialise(
self.data, self.settings['postprocessors_settings'][postproc])
if self.print_info:
self.residual_table = cout.TablePrinter(2, 14, ['g', 'f'])
self.residual_table.print_header(['ts', 't'])
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
self.ts_max = self.data.ts + 1
# create folder for containing files if necessary
if not os.path.exists(self.settings['folder']):
os.makedirs(self.settings['folder'])
self.folder = self.settings['folder'] + '/'
if not os.path.exists(self.folder):
os.makedirs(self.folder)
self.filename = self.folder + self.data.settings['SHARPy'][
'case'] + '.data.h5'
# allocate list of classes to be saved
if self.settings['save_aero']:
self.ClassesToSave += (
sharpy.aero.models.aerogrid.Aerogrid,
sharpy.utils.datastructures.AeroTimeStepInfo,
)
if self.settings['save_struct']:
self.ClassesToSave += (
sharpy.structure.models.beam.Beam,
sharpy.utils.datastructures.StructTimeStepInfo,
)
def initialise(self, in_dict):
self.settings = in_dict
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
# check that the gust type is valid
if not (self.settings['gust_shape'] in self.implemented_gusts):
raise AttributeError('The gust shape ' +
self.settings['gust_shape'] +
' is not implemented')
self.gust = dict_of_gusts[self.settings['gust_shape']]()
# backward compatibility
temp_settings = self.settings['gust_parameters'].copy()
for key, value in self.settings.items():
if not key == 'gust_parameters':
temp_settings[key] = value
self.u_inf = self.settings['u_inf']
self.u_inf_direction = self.settings['u_inf_direction']
# set gust properties
self.gust.u_inf = self.u_inf
self.gust.u_inf_direction = self.u_inf_direction
self.gust.initialise(temp_settings)
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings:
self.data.settings[self.solver_id] = custom_settings
self.settings = self.data.settings[self.solver_id]
# else:custom_settings
else:
self.settings = data.settings[self.solver_id]
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
# Get consistent linearisation timestep
ii_step = self.settings['linearisation_tstep']
if type(ii_step) != int:
ii_step = self.settings['linearisation_tstep'].value
tsstruct0 = data.structure.timestep_info[ii_step]
tsaero0 = data.aero.timestep_info[ii_step]
# Create data.linear
self.data.linear = Linear(tsaero0, tsstruct0)
# Load available systems
import sharpy.linear.assembler
# Load roms
import sharpy.rom
lsys = ss_interface.initialise_system(self.settings['linear_system'])
lsys.initialise(data)
self.data.linear.linear_system = lsys
def initialise(self, in_dict):
self.in_dict = in_dict
settings.to_custom_types(self.in_dict, self.settings_types,
self.settings_default)
self.settings = self.in_dict
self.x_grid, self.y_grid, self.z_grid, self.vel = self.read_turbsim_bts(
self.settings['turbulent_field'])
if not self.settings['new_orientation'] == 'xyz':
# self.settings['new_orientation'] = 'zyx'
self.x_grid, self.y_grid, self.z_grid, self.vel = self.change_orientation(
self.x_grid, self.y_grid, self.z_grid, self.vel,
self.settings['new_orientation'])
self.bbox = self.get_field_bbox(self.x_grid, self.y_grid, self.z_grid)
if self.settings['print_info']:
cout.cout_wrap('The domain bbox is:', 1)
cout.cout_wrap(
' x = [' + str(self.bbox[0, 0]) + ', ' + str(self.bbox[0, 1]) +
']', 1)
cout.cout_wrap(
' y = [' + str(self.bbox[1, 0]) + ', ' + str(self.bbox[1, 1]) +
']', 1)
cout.cout_wrap(
' z = [' + str(self.bbox[2, 0]) + ', ' + str(self.bbox[2, 1]) +
']', 1)
def initialise(self, data):
self.data = data
self.settings = data.settings[self.solver_id]
settings.to_custom_types(self.settings, self.settings_types, self.settings_default)
self.solver = solver_interface.initialise_solver(self.settings['solver'])
self.solver.initialise(self.data, self.settings['solver_settings'])
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
# update beam orientation
# beam orientation is used as the parametrisation of the aero orientation
# too (it will come handy for the fully coupled simulation)
# euler = np.array([self.settings['roll'].value,
# self.settings['alpha'].value,
# self.settings['beta'].value])
# euler_rot = algebra.euler2rot(euler) # this is Cag
# quat = algebra.mat2quat(euler_rot.T)
# self.data.structure.update_orientation(quat, self.data.ts)
# self.data.aero.update_orientation(quat, self.data.ts)
self.update_step()
# init velocity generator
velocity_generator_type = gen_interface.generator_from_string(
self.settings['velocity_field_generator'])
self.velocity_generator = velocity_generator_type()
self.velocity_generator.initialise(
self.settings['velocity_field_input'])
def initialise(self, data, custom_settings=None):
self.data = data
try:
rom_method = data.linear.linear_system.uvlm.settings['rom_method'][0]
self.ss = data.linear.linear_system.uvlm.rom[rom_method].ss
self.ssrom = data.linear.linear_system.uvlm.ss
except IndexError:
self.ss = data.linear.linear_system.uvlm.ss
if not custom_settings:
self.settings = self.data.settings[self.solver_id]
else:
self.settings = custom_settings
settings_utils.to_custom_types(self.settings, self.settings_types, self.settings_default, self.settings_options)
scaling = self.data.linear.linear_system.uvlm.sys.ScalingFacts
if self.settings['frequency_unit'] == 'k':
self.w_to_k = scaling['length'] / scaling['speed']
else:
self.w_to_k = 1.
lb = self.settings['frequency_bounds'][0] / self.w_to_k
ub = self.settings['frequency_bounds'][1] / self.w_to_k
nfreqs = self.settings['num_freqs'].value
self.wv = np.linspace(lb, ub, nfreqs)
if not os.path.exists(self.settings['folder']):
os.makedirs(self.settings['folder'])
self.folder = self.settings['folder'] + '/' + self.data.settings['SHARPy']['case'] + '/frequencyresponse/'
if not os.path.exists(self.folder):
os.makedirs(self.folder)
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
# load info from dyn dictionary
self.data.structure.add_unsteady_information(
self.data.structure.dyn_dict, self.data.ts)
# create folder for containing files if necessary
if not os.path.exists(self.settings['folder']):
os.makedirs(self.settings['folder'])
self.folder = (self.settings['folder'] + '/' +
self.data.settings['SHARPy']['case'] +
'/beam_modal_analysis/')
if not os.path.exists(self.folder):
os.makedirs(self.folder)
self.filename_freq = (self.folder + 'tstep' + ("%06d" % self.data.ts) +
'_ModalFrequencies.dat')
self.filename_damp = (self.folder + 'tstep' + ("%06d" % self.data.ts) +
'_ModalDamping.dat')
self.filename_shapes = (self.folder + 'tstep' +
("%06d" % self.data.ts) + '_ModalShape')
def initialise(self, data):
self.data = data
self.settings = data.settings[self.solver_id]
settings.to_custom_types(self.settings, self.settings_types, self.settings_default)
self.dt = self.settings['dt']
self.aero_solver = solver_interface.initialise_solver(self.settings['aero_solver'])
self.aero_solver.initialise(self.data, self.settings['aero_solver_settings'])
self.data = self.aero_solver.data
# if there's data in timestep_info[>0], copy the last one to
# timestep_info[0] and remove the rest
self.cleanup_timestep_info()
# initialise postprocessors
self.postprocessors = dict()
if len(self.settings['postprocessors']) > 0:
self.with_postprocessors = True
for postproc in self.settings['postprocessors']:
self.postprocessors[postproc] = solver_interface.initialise_solver(postproc)
self.postprocessors[postproc].initialise(
self.data, self.settings['postprocessors_settings'][postproc], caller=self)
self.residual_table = cout.TablePrinter(2, 14, ['g', 'f'])
self.residual_table.field_length[0] = 6
self.residual_table.field_length[1] = 6
self.residual_table.print_header(['ts', 't'])
def initialise(self, in_dict):
self.in_dict = in_dict
settings.to_custom_types(self.in_dict,
self.settings_types,
self.settings_default,
no_ctype=True)
# load file
try:
self.deflection = np.loadtxt(self.in_dict['deflection_file'])
except OSError:
cout_utils.cout_wrap(
'Unable to find control surface deflection file input', 4)
raise FileNotFoundError('Could not locate deflection file: '
'{:s}'.format(
self.in_dict['deflection_file']))
else:
cout_utils.cout_wrap(
'\tSuccess loading file {:s}'.format(
self.in_dict['deflection_file']), 2)
# deflection velocity
self.deflection_dot = np.zeros_like(self.deflection)
self.deflection_dot[0:-1] = np.diff(
self.deflection) / self.in_dict['dt']
self.deflection_dot[-1] = 0
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings:
self.settings = custom_settings
else:
self.settings = data.settings[self.solver_id]
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
# Read initial state and input data and store in dictionary
self.read_files()
# Output folder
self.folder = self.settings['folder'] + '/' + self.data.settings[
'SHARPy']['case'] + '/lindynamicsim/'
if not os.path.exists(self.folder):
os.makedirs(self.folder)
# initialise postprocessors
self.postprocessors = dict()
if len(self.settings['postprocessors']) > 0:
self.with_postprocessors = True
for postproc in self.settings['postprocessors']:
self.postprocessors[postproc] = initialise_solver(postproc)
self.postprocessors[postproc].initialise(
self.data, self.settings['postprocessors_settings'][postproc])
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
# load info from dyn dictionary
# self.data.structure.add_unsteady_information(
# self.data.structure.dyn_dict, self.settings['num_steps'].value)
#
# # Define Newmark constants
# self.gamma = 0.5 + self.settings['newmark_damp'].value
# self.beta = 0.25*(self.gamma + 0.5)*(self.gamma + 0.5)
# Define the number of equations
self.lc_list = lagrangeconstraints.initialize_constraints(
self.data.structure.ini_mb_dict)
self.num_LM_eq = lagrangeconstraints.define_num_LM_eq(self.lc_list)
# Define the number of dofs
self.define_sys_size()
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types, self.settings_default)
def initialise(self, in_settings=None):
if in_settings is not None:
self.settings = in_settings
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default, self.settings_options)
try:
if self.settings['print_info']:
cout.cout_wrap('Initialising Krylov Model Order Reduction')
except ValueError:
pass
self.algorithm = self.settings['algorithm']
if self.algorithm not in self.supported_methods:
raise NotImplementedError(
'Algorithm %s not recognised, check for spelling or it'
'could be that is not yet implemented' % self.algorithm)
self.frequency = np.array(self.settings['frequency'])
self.r = self.settings['r'].value
self.restart_arnoldi = self.settings['restart_arnoldi'].value
try:
self.nfreq = self.frequency.shape[0]
except AttributeError:
self.nfreq = 1
def __init__(self, in_settings=None):
self._settings = True
if in_settings is None:
# call for documentation only
self._settings = False
self.ts = 0
self.settings_types['log_file'] = 'str'
self.settings_default['log_file'] = 'log'
if self._settings:
self.settings = in_settings
self.settings['SHARPy']['flow'] = self.settings['SHARPy']['flow']
settings.to_custom_types(self.settings['SHARPy'],
self.settings_types,
self.settings_default)
cout.cout_wrap.initialise(self.settings['SHARPy']['write_screen'],
self.settings['SHARPy']['write_log'],
self.settings['SHARPy']['log_folder'],
self.settings['SHARPy']['log_file'])
self.case_route = in_settings['SHARPy']['route'] + '/'
self.case_name = in_settings['SHARPy']['case']
for solver_name in in_settings['SHARPy']['flow']:
try:
dict_of_solvers[solver_name]
except KeyError:
exceptions.NotImplementedSolver(solver_name)
def initialise(self, data):
try:
self.settings = data.settings['LinearAssembler'][
'linear_system_settings']
except KeyError:
self.settings = None
settings.to_custom_types(self.settings,
self.settings_types,
self.settings_default,
no_ctype=True)
if self.settings['use_euler']:
self.settings['beam_settings']['use_euler'] = True
# Create Linear UVLM
self.uvlm = ss_interface.initialise_system('LinearUVLM')
self.uvlm.initialise(data,
custom_settings=self.settings['aero_settings'])
if self.settings['uvlm_filename'] == '':
self.uvlm.assemble(track_body=self.settings['track_body'])
else:
self.load_uvlm_from_file = True
# Create beam
self.beam = ss_interface.initialise_system('LinearBeam')
self.beam.initialise(data,
custom_settings=self.settings['beam_settings'])
for k, v in self.uvlm.linearisation_vectors.items():
self.linearisation_vectors[k] = v
for k, v in self.beam.linearisation_vectors.items():
self.linearisation_vectors[k] = v
self.get_gebm2uvlm_gains(data)
def initialise(self, in_dict, **kwargs):
structure = kwargs['data'].structure
self.settings = in_dict
settings.to_custom_types(self.settings,
self.settings_types,
self.settings_default,
no_ctype=True,
options=self.settings_options)
self.num_changes = len(self.settings['change_variable'])
if 'lumped_mass' in self.settings['change_variable']:
self.control_objects['lumped_mass'] = LumpedMassControl()
lumped_mass_variables = []
for i in range(self.num_changes):
var_type = self.settings['change_variable'][i]
if var_type == 'lumped_mass':
variable = ChangeLumpedMass(
var_index=self.settings['variable_index'][i],
file=self.settings['file_list'][i])
variable.initialise(structure)
self.variables.append(variable)
lumped_mass_variables.append(i)
self.control_objects['lumped_mass'].append(i)
else:
raise NotImplementedError(
'Variable {:s} not yet coded to be modified in runtime'.
format(var_type))
try:
self.control_objects['lumped_mass'].set_unchanged_vars_to_zero(
structure)
except KeyError:
pass
def initialise(self, data, input_dict=None):
self.data = data
if input_dict is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = input_dict
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
self.print_info = self.settings['print_info']
self.structural_solver = solver_interface.initialise_solver(
self.settings['structural_solver'])
self.structural_solver.initialise(
self.data, self.settings['structural_solver_settings'])
self.aero_solver = solver_interface.initialise_solver(
self.settings['aero_solver'])
self.aero_solver.initialise(self.structural_solver.data,
self.settings['aero_solver_settings'])
self.data = self.aero_solver.data
if self.print_info:
self.residual_table = cout.TablePrinter(
9, 8, ['g', 'g', 'f', 'f', 'f', 'f', 'f', 'f', 'f'])
self.residual_table.field_length[0] = 3
self.residual_table.field_length[1] = 3
self.residual_table.field_length[2] = 10
self.residual_table.print_header([
'iter', 'step', 'log10(res)', 'Fx', 'Fy', 'Fz', 'Mx', 'My',
'Mz'
])
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings,
self.settings_types,
self.settings_default,
no_ctype=True)
self.num_evals = self.settings['num_evals']
stability_folder_path = self.settings[
'folder'] + '/' + self.data.settings['SHARPy'][
'case'] + '/stability'
if not os.path.exists(stability_folder_path):
os.makedirs(stability_folder_path)
self.folder = stability_folder_path
if not os.path.exists(stability_folder_path):
os.makedirs(stability_folder_path)
if self.settings['print_info']:
cout.cout_wrap('Dynamical System Eigenvalues')
eigenvalue_description_file = stability_folder_path + '/eigenvaluetable.txt'
self.eigenvalue_table = modalutils.EigenvalueTable(
filename=eigenvalue_description_file)
# Output dict
self.data.linear.stability = dict()
def initialise(self, data, custom_settings=None, caller=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default, self.settings_options)
self.dir = self.data.case_route + 'output/' + self.data.case_name + '/' + 'GenerateFlowField/'
if not os.path.isdir(self.dir):
os.makedirs(self.dir)
# init velocity generator
velocity_generator_type = gen_interface.generator_from_string(
self.settings['velocity_field_generator'])
self.velocity_generator = velocity_generator_type()
self.velocity_generator.initialise(
self.settings['velocity_field_input'])
# init postproc grid generator
postproc_grid_generator_type = gen_interface.generator_from_string(
self.settings['postproc_grid_generator'])
self.postproc_grid_generator = postproc_grid_generator_type()
self.postproc_grid_generator.initialise(
self.settings['postproc_grid_input'])
self.caller = caller
def initialise(self, in_dict):
self.in_dict = in_dict
settings.to_custom_types(self.in_dict, self.settings_types,
self.settings_default)
self.u_inf = self.in_dict['u_inf']
self.u_inf_direction = self.in_dict['u_inf_direction']
def initialise(self, data, custom_settings=None):
self.data = data
if custom_settings is None:
self.settings = data.settings[self.solver_id]
else:
self.settings = custom_settings
settings.to_custom_types(self.settings, self.settings_types, self.settings_default)
self.ts_max = len(self.data.structure.timestep_info)
def initialise(self, in_dict):
self.in_dict = in_dict
settings.to_custom_types(self.in_dict, self.settings_types,
self.settings_default)
# input validation
self.in_dict['shape'] = self.in_dict['shape'].lower()
self.in_dict['acceleration'] = self.in_dict['acceleration'].lower()
def initialise(self, data):
self.data = data
self.settings = data.settings[self.solver_id]
if self.data.structure.settings['unsteady']:
self.ts_max = self.data.structure.settings['num_steps']
else:
self.ts_max = 1
settings.to_custom_types(self.settings, self.settings_types, self.settings_default)
def initialise(self, data):
self.data = data
self.settings = data.settings[self.solver_id]
settings.to_custom_types(self.settings, self.settings_types,
self.settings_default)
# load info from dyn dictionary
self.data.structure.add_unsteady_information(
self.data.structure.dyn_dict, self.settings['num_steps'].value)
def initialise(self, data):
self.data = data
self.settings = data.settings[self.solver_id]
# init settings
settings.to_custom_types(self.settings, self.settings_types, self.settings_default)
# read input files (fem and dyn)
self.read_files()
def initialise(self, data):
self.data = data
self.settings = data.settings[self.solver_id]
if self.data.structure.settings['unsteady']:
self.ts_max = self.data.ts + 1
else:
self.ts_max = 1
self.ts_max = len(self.data.structure.timestep_info)
settings.to_custom_types(self.settings, self.settings_types, self.settings_default)
