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, 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)
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):
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'])
self.table = cout.TablePrinter(10, 8, ['g', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f'])
self.table.print_header(['iter', 'alpha', 'elev', 'thrust', 'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'])
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'].value
self.solver = solver_interface.initialise_solver(
self.settings['trajectory_solver'])
self.settings['trajectory_solver_settings']['n_time_steps'] = 1
self.solver.initialise(self.data,
self.settings['trajectory_solver_settings'])
self.n_controlled_points = len(self.settings['nodes_trajectory'])
# initialized controllers for the trayectory nodes
# there will be 3 controllers per node (one per dimension)
for i_trajec in range(self.n_controlled_points):
self.controllers.append(list())
for i_dim in range(3):
self.controllers[i_trajec].append(
PID(self.settings['PID_P_gain'].value,
self.settings['PID_I_gain'].value,
self.settings['PID_D_gain'].value, self.dt))
self.trajectory = np.zeros((self.settings['n_time_steps'].value,
len(self.settings['nodes_trajectory']), 3))
self.input_trajectory = np.zeros(
(self.settings['n_time_steps'].value,
len(self.settings['nodes_trajectory']), 3))
self.force_history = np.zeros(
(self.settings['n_time_steps'].value,
len(self.settings['nodes_trajectory']), 3))
# initialise trayectory generator
trajectory_generator_type = gen_interface.generator_from_string(
self.settings['trajectory_generator'])
self.trajectory_generator = trajectory_generator_type()
self.trajectory_generator.initialise(
self.settings['trajectory_generator_input'])
self.trajectory_steps = self.trajectory_generator.get_n_steps()
# generate coordinates offset in order to be able to use only one
# generator
self.ini_coord_a = self.data.structure.ini_info.glob_pos(
include_rbm=False)
self.print_info = self.settings['print_info']
if self.print_info:
self.residual_table = cout.TablePrinter(4, 14,
['g', 'f', 'f', 'e'])
self.residual_table.field_length[0] = 6
self.residual_table.field_length[1] = 6
self.residual_table.field_length[1] = 6
self.residual_table.print_header(
['ts', 't', 'traj. offset', 'norm(force)'])
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']
if self.settings['cleanup_previous_solution']:
# if there's data in timestep_info[>0], copy the last one to
# timestep_info[0] and remove the rest
self.cleanup_timestep_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(
7, 14, ['g', 'f', 'g', 'f', 'f', 'f', 'e'])
self.residual_table.field_length[0] = 6
self.residual_table.field_length[1] = 6
self.residual_table.field_length[1] = 6
self.residual_table.print_header([
'ts', 't', 'iter', 'residual pos', 'residual vel',
'residual acc', 'FoR_vel(z)'
])
# 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])
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.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'
])
# 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):
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'])
folder = self.settings['folder'] + '/' + self.data.settings['SHARPy'][
'case'] + '/statictrim/'
if not os.path.exists(folder):
os.makedirs(folder)
self.table = cout.TablePrinter(
10,
8, ['g', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f'],
filename=folder + 'trim_iterations.txt')
self.table.print_header([
'iter', 'alpha[deg]', 'elev[deg]', 'thrust', 'Fx', 'Fy', 'Fz',
'Mx', 'My', 'Mz'
])
def initialise(self, data, custom_settings=None):
"""
Controls the initialisation process of the solver, including processing
the settings and initialising the aero and structural solvers, postprocessors
and controllers.
"""
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.original_settings = copy.deepcopy(self.settings)
self.dt = self.settings['dt']
self.substep_dt = (self.dt.value /
(self.settings['structural_substeps'].value + 1))
self.initial_n_substeps = self.settings['structural_substeps'].value
self.print_info = self.settings['print_info']
if self.settings['cleanup_previous_solution']:
# if there's data in timestep_info[>0], copy the last one to
# timestep_info[0] and remove the rest
self.cleanup_timestep_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
# initialise postprocessors
self.postprocessors = dict()
if self.settings['postprocessors']:
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])
# initialise controllers
self.controllers = dict()
self.with_controllers = False
if self.settings['controller_id']:
self.with_controllers = True
for controller_id, controller_type in self.settings[
'controller_id'].items():
self.controllers[controller_id] = (
controller_interface.initialise_controller(controller_type))
self.controllers[controller_id].initialise(
self.settings['controller_settings'][controller_id],
controller_id)
# print information header
if self.print_info:
self.residual_table = cout.TablePrinter(
8, 12, ['g', 'f', 'g', 'f', 'f', 'f', 'e', 'e'])
self.residual_table.field_length[0] = 5
self.residual_table.field_length[1] = 6
self.residual_table.field_length[2] = 4
self.residual_table.print_header([
'ts', 't', 'iter', 'struc ratio', 'iter time', 'residual vel',
'FoR_vel(x)', 'FoR_vel(z)'
])
def initialise(self, data, custom_settings=None):
"""
Controls the initialisation process of the solver, including processing
the settings and initialising the aero and structural solvers, postprocessors
and controllers.
"""
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,
options=self.settings_options)
self.original_settings = copy.deepcopy(self.settings)
self.dt = self.settings['dt']
self.substep_dt = (self.dt.value /
(self.settings['structural_substeps'].value + 1))
self.initial_n_substeps = self.settings['structural_substeps'].value
self.print_info = self.settings['print_info']
if self.settings['cleanup_previous_solution']:
# if there's data in timestep_info[>0], copy the last one to
# timestep_info[0] and remove the rest
self.cleanup_timestep_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
# initialise postprocessors
self.postprocessors = dict()
if self.settings['postprocessors']:
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)
# initialise controllers
self.controllers = dict()
self.with_controllers = False
if self.settings['controller_id']:
self.with_controllers = True
for controller_id, controller_type in self.settings[
'controller_id'].items():
self.controllers[controller_id] = (
controller_interface.initialise_controller(controller_type))
self.controllers[controller_id].initialise(
self.settings['controller_settings'][controller_id],
controller_id)
# print information header
if self.print_info:
self.residual_table = cout.TablePrinter(
8, 12, ['g', 'f', 'g', 'f', 'f', 'f', 'e', 'e'])
self.residual_table.field_length[0] = 5
self.residual_table.field_length[1] = 6
self.residual_table.field_length[2] = 4
self.residual_table.print_header([
'ts', 't', 'iter', 'struc ratio', 'iter time', 'residual vel',
'FoR_vel(x)', 'FoR_vel(z)'
])
# 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']]
# check for empty dictionary
if self.settings['network_settings']:
self.network_loader = network_interface.NetworkLoader()
self.network_loader.initialise(
in_settings=self.settings['network_settings'])
# initialise runtime generators
self.runtime_generators = dict()
if self.settings['runtime_generators']:
self.with_runtime_generators = True
for id, param in self.settings['runtime_generators'].items():
gen = gen_interface.generator_from_string(id)
self.runtime_generators[id] = gen()
self.runtime_generators[id].initialise(param, data=self.data)
def derivatives(self, Y_freq):
Cng = np.array([[-1, 0, 0], [0, 1, 0],
[0, 0,
-1]]) # Project SEU on NED - TODO implementation
u_inf = self.settings['u_inf'].value
s_ref = self.settings['S_ref'].value
b_ref = self.settings['b_ref'].value
c_ref = self.settings['c_ref'].value
rho = self.data.linear.tsaero0.rho
# Inertial frame
try:
euler = self.data.linear.tsstruct0.euler
Pga = algebra.euler2rot(euler)
rig_dof = 9
except AttributeError:
quat = self.data.linear.tsstruct0.quat
Pga = algebra.quat2rotation(quat)
rig_dof = 10
derivatives_g = np.zeros((6, Y_freq.shape[1] + 2))
coefficients = {
'force':
0.5 * rho * u_inf**2 * s_ref,
'moment_lon':
0.5 * rho * u_inf**2 * s_ref * c_ref,
'moment_lat':
0.5 * rho * u_inf**2 * s_ref * b_ref,
'force_angular_vel':
0.5 * rho * u_inf**2 * s_ref * c_ref / u_inf,
'moment_lon_angular_vel':
0.5 * rho * u_inf**2 * s_ref * c_ref * c_ref / u_inf
} # missing rates
for in_channel in range(Y_freq.shape[1]):
derivatives_g[:3, in_channel] = Pga.dot(Y_freq[:3, in_channel])
derivatives_g[3:, in_channel] = Pga.dot(Y_freq[3:, in_channel])
derivatives_g[:3, :3] /= coefficients['force']
derivatives_g[:3, 3:6] /= coefficients['force_angular_vel']
derivatives_g[4, :3] /= coefficients['moment_lon']
derivatives_g[4, 3:6] /= coefficients['moment_lon_angular_vel']
derivatives_g[[3, 5], :] /= coefficients['moment_lat']
derivatives_g[:, -2] = derivatives_g[:, 2] * u_inf # ders wrt alpha
derivatives_g[:, -1] = derivatives_g[:, 1] * u_inf # ders wrt beta
der_matrix = np.zeros((6, self.inputs - (rig_dof - 6)))
der_col = 0
for i in list(range(6)) + list(range(rig_dof, self.inputs)):
der_matrix[:3, der_col] = Y_freq[:3, i]
der_matrix[3:6, der_col] = Y_freq[3:6, i]
der_col += 1
labels_force = {0: 'X', 1: 'Y', 2: 'Z', 3: 'L', 4: 'M', 5: 'N'}
labels_velocity = {
0: 'u',
1: 'v',
2: 'w',
3: 'p',
4: 'q',
5: 'r',
6: 'flap1',
7: 'flap2',
8: 'flap3'
}
table = cout.TablePrinter(
n_fields=7,
field_length=12,
field_types=['s', 'f', 'f', 'f', 'f', 'f', 'f'])
table.print_header(['der'] + list(labels_force.values()))
for i in range(der_matrix.shape[1]):
table.print_line([labels_velocity[i]] + list(der_matrix[:, i]))
table_coeff = cout.TablePrinter(n_fields=7,
field_length=12,
field_types=['s'] + 6 * ['f'])
labels_out = {
0: 'C_D',
1: 'C_Y',
2: 'C_L',
3: 'C_l',
4: 'C_m',
5: 'C_n'
}
labels_der = {
0: 'u',
1: 'v',
2: 'w',
3: 'p',
4: 'q',
5: 'r',
6: 'alpha',
7: 'beta'
}
table_coeff.print_header(['der'] + list(labels_out.values()))
for i in range(6):
table_coeff.print_line([labels_der[i]] + list(derivatives_g[:, i]))
table_coeff.print_line([labels_der[6]] + list(derivatives_g[:, -2]))
table_coeff.print_line([labels_der[7]] + list(derivatives_g[:, -1]))
return der_matrix, derivatives_g
