def __init__(self, cosim_solver_settings, level):
super(MDoFSolver, self).__init__(cosim_solver_settings, level)
input_file_name = self.cosim_solver_settings["input_file"]
if not input_file_name.endswith(".json"):
input_file_name += ".json"
with open(input_file_name, 'r') as ProjectParameters:
parameters = json.load(ProjectParameters)
# creating model using a certain module
model_type = parameters["model_parameters"]["type"]
model_module = __import__("mdof_" + model_type + "_model")
self.model = model_module.CreateModel(parameters["model_parameters"])
# creating model using a certain module
scheme_type = parameters["time_integration_scheme_parameters"]["type"]
scheme_module = __import__("time_integration_" + scheme_type +
"_scheme")
# adding the number of dofs for the constructor of the scheme
nr_of_dofs = len(self.model.u0)
if "settings" in parameters["time_integration_scheme_parameters"]:
parameters["time_integration_scheme_parameters"][
"settings"].update({"nr_of_dofs": len(self.model.u0)})
else:
parameters["time_integration_scheme_parameters"].update(
{"settings": {
"nr_of_dofs": len(self.model.u0)
}})
self.scheme = scheme_module.CreateScheme(
parameters["time_integration_scheme_parameters"])
default_solver_settings = {"buffer_size": 3}
default_output_settings = {"file_name": "results_mdof.dat"}
# solver settings
RecursivelyValidateAndAssignDefaults(default_solver_settings,
parameters["solver_parameters"])
# output settings
RecursivelyValidateAndAssignDefaults(default_output_settings,
parameters["output_parameters"])
self.buffer_size = parameters["solver_parameters"]["buffer_size"]
self.output_file_name = parameters["output_parameters"]["file_name"]
# PMT this might not be needed
self.load_vector = None
# 1st dimension: variables: disp, acc, vel
# 2nd dimension: buffer size -> specified by user
# see distinction to the buffer size for the scheme which is scheme-specific
# 3rd dimension: number of dofs
self.buffer = np.zeros((3, self.buffer_size, nr_of_dofs))
def __init__(self, model_settings):
default_settings = {
"type": "bridge_2dof",
"system_parameters": {
"length_of_section": 0.75,
"help":
"1st value - translational dof, 2nd value - rotational dof",
"mass_per_length": [5.0, 0.025],
"target_frequency": [2.75, 2],
"damping_log_decr": [0.05, 0.10]
},
"initial_conditions": {
"displacement": [0.05, 0.35],
"velocity": [0.0, 0.0],
"acceleration": [0.0, 0.0],
"external_force": [0.0, 0.0]
}
}
RecursivelyValidateAndAssignDefaults(default_settings, model_settings)
l = model_settings["system_parameters"]["length_of_section"]
# heave (translation)
# mass over unit length as input
m = model_settings["system_parameters"]["mass_per_length"][0]
m_h = m * l
f_h = model_settings["system_parameters"]["target_frequency"][0]
k_h = m_h * ((2 * np.pi * f_h)**2)
logd_h = model_settings["system_parameters"]["damping_log_decr"][0]
# pitch (rotation)
# inertia over unit length as input
I = model_settings["system_parameters"]["mass_per_length"][1]
m_r = I * l
f_r = model_settings["system_parameters"]["target_frequency"][1]
k_r = m_r * ((2 * np.pi * f_r)**2)
logd_r = model_settings["system_parameters"]["damping_log_decr"][1]
self.m = self._CalculateMass(m_h, m_r)
self.k = self._CalculateStiffness(k_h, k_r)
self.b = self._CalculateDamping(m_h, m_r, k_h, k_r, logd_h, logd_r)
# needed as placeholder
self.nodal_coordinates = {"x0": None, "y0": None, "x": None, "y": None}
initial_values = self._SetupInitialValues(
model_settings['initial_conditions'])
self.u0 = initial_values["displacement"]
self.v0 = initial_values["velocity"]
self.a0 = initial_values["acceleration"]
self.f0 = initial_values["external_force"]
def __init__(self, model_settings):
default_settings = {
"type": "cantilever_eb_beam_2d",
"system_parameters":{
"density" : 5.0,
"area" : 10.0,
"target_frequency" : 1.0,
"target_mode" : 1,
"damping_ratio" : 0.05,
"level_height" : 3.5,
"number_of_levels" : 3
},
"initial_conditions":{
"displacement" : "none",
"velocity" : "none",
"acceleration" : "none",
"external_force": "none"
}
}
RecursivelyValidateAndAssignDefaults(default_settings, model_settings)
rho = model_settings["system_parameters"]["density"]
area = model_settings["system_parameters"]["area"]
target_freq = model_settings["system_parameters"]["target_frequency"]
# adjust index
target_mode = model_settings["system_parameters"]["target_mode"] - 1
zeta = model_settings["system_parameters"]["damping_ratio"]
level_height = model_settings["system_parameters"]["level_height"]
num_of_levels = model_settings["system_parameters"]["number_of_levels"]
self.m = self._CalculateMass(rho, area, level_height, num_of_levels)
self.k = self._CalculateStiffness(self.m, level_height, num_of_levels, target_freq, target_mode)
self.b = self._CalculateDamping(self.m, self.k, zeta)
height_coordinates = self._GetNodalCoordinates(level_height, num_of_levels)
self.nodal_coordinates = {'x0': np.zeros(len(height_coordinates)),
'y0': height_coordinates,
'x': None,
'y': None}
initial_values = self._SetupInitialValues(model_settings['initial_conditions'],
self.nodal_coordinates['y0'])
self.u0 = initial_values["displacement"]
self.v0 = initial_values["velocity"]
self.a0 = initial_values["acceleration"]
self.f0 = initial_values["external_force"]
def __init__(self, model_settings):
default_settings = {
"type": "sdof",
"system_parameters": {
"mass": 1.0,
"target_frequency": 2.0,
"damping_ratio": 0.0
},
"initial_conditions": {
"displacement": 0.5,
"velocity": 0.0,
"acceleration": 0.0,
"external_force": 0.0
}
}
RecursivelyValidateAndAssignDefaults(default_settings, model_settings)
m = model_settings["system_parameters"]["mass"]
target_freq = model_settings["system_parameters"]["target_frequency"]
zeta = model_settings["system_parameters"]["damping_ratio"]
k = self._CalculateStiffness(m, target_freq)
b = self._CalculateDamping(m, k, zeta)
# needed as placeholder
self.nodal_coordinates = {"x0": None, "y0": None, "x": None, "y": None}
# mass, stiffness and damping matrices
self.m = np.array([[m]])
self.k = np.array([[k]])
self.b = np.array([[b]])
# initial conditions - displacement, velocity, acceleration, external force
self.u0 = np.array(
[model_settings["initial_conditions"]["displacement"]])
self.v0 = np.array([model_settings["initial_conditions"]["velocity"]])
self.a0 = np.array(
[model_settings["initial_conditions"]["acceleration"]])
self.f0 = np.array(
[model_settings["initial_conditions"]["external_force"]])
def __init__(self, cosim_solver_settings, level):
super(SDoFStaticSolver, self).__init__(cosim_solver_settings, level)
input_file_name = self.cosim_solver_settings["input_file"]
if not input_file_name.endswith(".json"):
input_file_name += ".json"
with open(input_file_name, 'r') as ProjectParameters:
parameters = json.load(ProjectParameters)
default_settings = {
"system_parameters": {
"stiffness": 4000.0
},
"initial_values": {
"displacement": 0.0,
},
"boundary_conditions": {
"external_load": 5000.0
},
"solver_parameters": {
"buffer_size": 1
},
"output_parameters": {
"file_name": "sdof_static_solver/results_sdof.dat"
}
}
RecursivelyValidateAndAssignDefaults(default_settings, parameters)
self.stiffness = parameters["system_parameters"]["stiffness"]
self.initial_displacement = parameters["initial_values"][
"displacement"]
self.force = parameters["boundary_conditions"]["external_load"]
self.buffer_size = parameters["solver_parameters"]["buffer_size"]
self.output_file_name = parameters["output_parameters"]["file_name"]
def __init__(self, cosim_solver_settings, level):
super(SDoFSolver, self).__init__(cosim_solver_settings, level)
input_file_name = self.cosim_solver_settings["input_file"]
if not input_file_name.endswith(".json"):
input_file_name += ".json"
with open(input_file_name, 'r') as ProjectParameters:
parameters = json.load(ProjectParameters)
default_settings = {
"system_parameters": {
"mass": 100.0,
"stiffness": 4000.0,
"damping": 6000.0
},
"time_integration_parameters": {
"alpha_m": -0.5,
"alpha_f": -0.5,
"time_step": 0.05
},
"initial_values": {
"displacement": 0.0,
"velocity": 0.0,
"acceleration": 0.0
},
"boundary_conditions": {
"external_load": 5000.0
},
"solver_parameters": {
"buffer_size": 3
},
"output_parameters": {
"file_name": "sdof_solver/results_sdof.dat"
}
}
RecursivelyValidateAndAssignDefaults(default_settings, parameters)
self.mass = parameters["system_parameters"]["mass"]
self.stiffness = parameters["system_parameters"]["stiffness"]
self.damping = parameters["system_parameters"]["damping"]
self.alpha_m = parameters["time_integration_parameters"]["alpha_m"]
self.alpha_f = parameters["time_integration_parameters"]["alpha_f"]
self.delta_t = parameters["time_integration_parameters"]["time_step"]
self.initial_displacement = parameters["initial_values"][
"displacement"]
self.initial_velocity = parameters["initial_values"]["velocity"]
self.force = parameters["boundary_conditions"]["external_load"]
#calculate initial acceleration
factor = self.force - self.stiffness * self.initial_displacement
self.initial_acceleration = (1 / self.mass) * factor
beta = 0.25 * (1 - self.alpha_m + self.alpha_f)**2
gamma = 0.50 - self.alpha_m + self.alpha_f
self.LHS = np.array([[1.0, 0.0, -self.delta_t**2 * beta],
[0.0, 1.0, -self.delta_t * gamma],
[(1 - self.alpha_f) * self.stiffness,
(1 - self.alpha_f) * self.damping,
(1 - self.alpha_m) * self.mass]])
self.RHS_matrix = np.array(
[[1.0, self.delta_t, self.delta_t**2 * (0.5 - beta)],
[0.0, 1.0, self.delta_t * (1 - gamma)],
[
-self.alpha_f * self.stiffness, -self.alpha_f * self.damping,
-self.alpha_m * self.mass
]])
self.buffer_size = parameters["solver_parameters"]["buffer_size"]
self.output_file_name = parameters["output_parameters"]["file_name"]