def __init__(self, identifier, project_parameters, model_part):
self.identifier = identifier
model = Model()
model.AddModelPart(model_part)
# Create the primal solver
with open(project_parameters["primal_settings"].GetString(),
'r') as parameter_file:
ProjectParametersPrimal = Parameters(parameter_file.read())
self.primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, ProjectParametersPrimal)
self.primal_model_part_name = ProjectParametersPrimal["problem_data"][
"model_part_name"].GetString()
# Create the adjoint solver
with open(project_parameters["adjoint_settings"].GetString(),
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
ProjectParametersAdjoint["solver_settings"].AddValue(
"response_function_settings", project_parameters)
adjoint_model = Model()
# TODO find out why it is not possible to use the same model_part
self.adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
adjoint_model, ProjectParametersAdjoint)
self.adjoint_model_part_name = ProjectParametersAdjoint[
"problem_data"]["model_part_name"].GetString()
def __init__(self, identifier, response_settings, model):
self.identifier = identifier
self.response_settings = response_settings
# Create the primal solver
with open(self.response_settings["primal_settings"].GetString(),
'r') as parameter_file:
primal_parameters = Parameters(parameter_file.read())
self.primal_model_part = _GetModelPart(
model, primal_parameters["solver_settings"])
self.primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, primal_parameters)
# Create the adjoint solver
adjoint_parameters = self._GetAdjointParameters()
adjoint_model = KratosMultiphysics.Model()
self.adjoint_model_part = _GetModelPart(
adjoint_model, adjoint_parameters["solver_settings"])
# TODO find out why it is not possible to use the same model_part
self.adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
adjoint_model, adjoint_parameters)
self.primal_state_variables = [KratosMultiphysics.DISPLACEMENT]
if primal_parameters["solver_settings"].Has("rotation_dofs"):
if primal_parameters["solver_settings"]["rotation_dofs"].GetBool():
self.primal_state_variables.append(KratosMultiphysics.ROTATION)
def test_execution(self):
# Within this location context:
with controlledExecutionScope(os.path.dirname(os.path.realpath(__file__))):
model_save = KratosMultiphysics.Model()
model_load = KratosMultiphysics.Model()
structural_mechanics_analysis.StructuralMechanicsAnalysis(model_save, self.project_parameters_save).Run()
structural_mechanics_analysis.StructuralMechanicsAnalysis(model_load, self.project_parameters_load).Run()
def test_harmonic_mdpa_input(self):
if not kratos_utils.CheckIfApplicationsAvailable("HDF5Application"):
self.skipTest(
"HDF5Application not found: Skipping harmonic analysis mdpa test"
)
import structural_mechanics_analysis
with ControlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
#run simulation and write to hdf5 file
model = KratosMultiphysics.Model()
project_parameter_file_name = "harmonic_analysis_test/harmonic_analysis_test_eigenproblem_parameters.json"
with open(project_parameter_file_name, 'r') as parameter_file:
project_parameters = KratosMultiphysics.Parameters(
parameter_file.read())
test = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, project_parameters)
test.Run()
#start new simulation and read from hdf5 file
model = KratosMultiphysics.Model()
project_parameter_file_name = "harmonic_analysis_test/harmonic_analysis_test_parameters.json"
with open(project_parameter_file_name, 'r') as parameter_file:
project_parameters = KratosMultiphysics.Parameters(
parameter_file.read())
test = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, project_parameters)
test.Run()
# remove hdf5 file
kratos_utils.DeleteFileIfExisting(
"harmonic_analysis_test/eigen_results.h5")
kratos_utils.DeleteFileIfExisting(
"harmonic_analysis_test/harmonic_analysis_test.time")
def test_harmonic_mdpa_input(self):
try:
import KratosMultiphysics.HDF5Application as HDF5Application
except ImportError as e:
self.skipTest(
"HDF5Application not found: Skipping harmonic analysis mdpa test"
)
import structural_mechanics_analysis
with ControlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
#run simulation and write to hdf5 file
project_parameter_file_name = "harmonic_analysis_test/harmonic_analysis_test_eigenproblem_parameters.json"
test = structural_mechanics_analysis.StructuralMechanicsAnalysis(
project_parameter_file_name)
test.Run()
#start new simulation and read from hdf5 file
project_parameter_file_name = "harmonic_analysis_test/harmonic_analysis_test_parameters.json"
test = structural_mechanics_analysis.StructuralMechanicsAnalysis(
project_parameter_file_name)
test.Run()
# remove hdf5 file
kratos_utils.DeleteFileIfExisting(
"harmonic_analysis_test/eigen_results.h5")
kratos_utils.DeleteFileIfExisting(
"harmonic_analysis_test/harmonic_analysis_test.time")
def test_execution(self):
# Within this location context:
with controlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
structural_mechanics_analysis.StructuralMechanicsAnalysis(
self.project_parameters_save).Run()
structural_mechanics_analysis.StructuralMechanicsAnalysis(
self.project_parameters_load).Run()
def test_local_stress_response(self):
# Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("linear_shell_test_local_stress_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["solver_settings"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter THICKNESS
reference_values = [
1.7135092490964121, -6.860092387341681, 0.14749301178647778
]
sensitivities_to_check = []
element_list = [1, 2, 8]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(THICKNESS_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0],
reference_values[0], 5)
self.assertAlmostEqual(sensitivities_to_check[1],
reference_values[1], 5)
self.assertAlmostEqual(sensitivities_to_check[2],
reference_values[2], 5)
def test_strain_energy_response(self):
# Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open(
"linear_shell_test_strain_energy_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["solver_settings"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter THICKNESS
reference_values = [
-0.4958006682716821, -1.1674087588549331, -0.2471256044520311
]
sensitivities_to_check = []
element_list = [1, 2, 8]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(THICKNESS_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0],
reference_values[0], 5)
self.assertAlmostEqual(sensitivities_to_check[1],
reference_values[1], 5)
self.assertAlmostEqual(sensitivities_to_check[2],
reference_values[2], 5)
def __init__(self, identifier, response_settings, model_part):
self.identifier = identifier
self.primal_model_part = model_part
self.response_function_utility = StructuralMechanicsApplication.EigenfrequencyResponseFunctionUtility(model_part, response_settings)
with open(response_settings["primal_settings"].GetString()) as parameters_file:
ProjectParametersPrimal = Parameters(parameters_file.read())
eigen_solver_settings = ProjectParametersPrimal["solver_settings"]["eigensolver_settings"]
max_required_eigenfrequency = int(max(response_settings["traced_eigenfrequencies"].GetVector()))
if max_required_eigenfrequency is not eigen_solver_settings["number_of_eigenvalues"].GetInt():
print("\n> WARNING: Specified number of eigenvalues in the primal analysis and the max required eigenvalue according the response settings do not match!!!")
print(" Primal parameters were adjusted accordingly!\n")
eigen_solver_settings["number_of_eigenvalues"].SetInt(max_required_eigenfrequency)
if not eigen_solver_settings.Has("normalize_eigenvectors"):
eigen_solver_settings.AddEmptyValue("normalize_eigenvectors")
eigen_solver_settings["normalize_eigenvectors"].SetBool(True)
print("\n> WARNING: Eigenfrequency response function requires mass normalization of eigenvectors!")
print(" Primal parameters were adjusted accordingly!\n")
if not eigen_solver_settings["normalize_eigenvectors"].GetBool():
eigen_solver_settings["normalize_eigenvectors"].SetBool(True)
print("\n> WARNING: Eigenfrequency response function requires mass normalization of eigenvectors!")
print(" Primal parameters were adjusted accordingly!\n")
model = Model()
model.AddModelPart(self.primal_model_part)
self.primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(model, ProjectParametersPrimal)
self.primal_model_part.AddNodalSolutionStepVariable(SHAPE_SENSITIVITY)
def test_nodal_displacement_response(self):
# Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("linear_shell_test_nodal_disp_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["solver_settings"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter THICKNESS
reference_values = [
-0.09916013365433643, -0.23348175177098657,
-0.04942512089147077
]
sensitivities_to_check = []
element_list = [1, 2, 8]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(THICKNESS_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0],
reference_values[0], 5)
self.assertAlmostEqual(sensitivities_to_check[1],
reference_values[1], 5)
self.assertAlmostEqual(sensitivities_to_check[2],
reference_values[2], 5)
def test_nodal_displacement_response(self):
# Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("beam_test_nodal_disp_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["solver_settings"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter I22
reference_values = [
-0.45410279537614157, -0.37821875982596204,
-0.006200296058668847
]
sensitivities_to_check = []
element_list = [1, 6, 10]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(I22_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0], reference_values[0],
4)
self.assertAlmostEqual(sensitivities_to_check[1], reference_values[1],
4)
self.assertAlmostEqual(sensitivities_to_check[2], reference_values[2],
4)
def test_local_stress_response(self):
#Create the adjoint solver
with open(
"./adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_local_stress_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["problem_data"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter I22
reference_values = [
-87622.77099397512, 38125.18144970003, 625.0029074349038
]
sensitivities_to_check = []
element_list = [1, 6, 10]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(I22_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0], reference_values[0],
5)
self.assertAlmostEqual(sensitivities_to_check[1], reference_values[1],
5)
self.assertAlmostEqual(sensitivities_to_check[2], reference_values[2],
5)
def test_strain_energy_response(self):
# Create the adjoint solver
with open(
"./adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_strain_energy_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["problem_data"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter I22
reference_values = [
-9082.055913430777, -7564.375188032661, -124.00616062621255
]
sensitivities_to_check = []
element_list = [1, 6, 10]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(I22_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0], reference_values[0],
5)
self.assertAlmostEqual(sensitivities_to_check[1], reference_values[1],
5)
self.assertAlmostEqual(sensitivities_to_check[2], reference_values[2],
5)
def test_nodal_displacement_response(self):
# Create the adjoint solver
with open(
"./adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_nodal_disp_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["problem_data"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter I22
reference_values = [
-454.1027959305903, -378.2187594016309, -6.200311358415619
]
sensitivities_to_check = []
element_list = [1, 6, 10]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(I22_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0], reference_values[0],
5)
self.assertAlmostEqual(sensitivities_to_check[1], reference_values[1],
5)
self.assertAlmostEqual(sensitivities_to_check[2], reference_values[2],
5)
def test_local_stress_response(self):
#Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("beam_test_local_stress_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["solver_settings"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter I22
reference_values = [
-87.62277093392399, 38.125186783868, 0.6250049974719261
]
sensitivities_to_check = []
element_list = [1, 6, 10]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(I22_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0], reference_values[0],
3)
self.assertAlmostEqual(sensitivities_to_check[1], reference_values[1],
3)
self.assertAlmostEqual(sensitivities_to_check[2], reference_values[2],
3)
def test_strain_energy_response(self):
# Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("beam_test_strain_energy_adjoint_parameters.json",
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
model_part_name = ProjectParametersAdjoint["solver_settings"][
"model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivities for the parameter I22
reference_values = [
-9.082055907522943, -7.5643751965193164, -0.12400592117339182
]
sensitivities_to_check = []
element_list = [1, 6, 10]
for element_id in element_list:
sensitivities_to_check.append(
model_adjoint.GetModelPart(model_part_name).
Elements[element_id].GetValue(I22_SENSITIVITY))
self.assertAlmostEqual(sensitivities_to_check[0], reference_values[0],
4)
self.assertAlmostEqual(sensitivities_to_check[1], reference_values[1],
4)
self.assertAlmostEqual(sensitivities_to_check[2], reference_values[2],
4)
def __init__(self, identifier, response_settings, model_part=None):
self.identifier = identifier
self.response_settings = response_settings
if not response_settings.Has("weighting_method") or response_settings[
"weighting_method"].GetString() == "none":
self.response_function_utility = StructuralMechanicsApplication.EigenfrequencyResponseFunctionUtility(
model_part, response_settings)
elif response_settings["weighting_method"].GetString(
) == "linear_scaling":
self.response_function_utility = StructuralMechanicsApplication.EigenfrequencyResponseFunctionLinScalUtility(
model_part, response_settings)
else:
raise NameError(
"The following weighting_method is not valid for eigenfrequency response: "
+ response_settings["weighting_method"].GetString() +
".\nAvailable weighting methods are: 'none', 'linear_scaling'. Default: 'none'"
)
with open(response_settings["primal_settings"].GetString()
) as parameters_file:
ProjectParametersPrimal = Parameters(parameters_file.read())
self.primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
ProjectParametersPrimal, model_part)
self.primal_analysis.GetModelPart().AddNodalSolutionStepVariable(
SHAPE_SENSITIVITY)
def solve_primal_problem():
with open(
"./adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_parameters.json",
'r') as parameter_file:
ProjectParametersPrimal = Parameters(parameter_file.read())
model_primal = Model()
primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_primal, ProjectParametersPrimal)
primal_analysis.Run()
def test_local_stress_response(self):
#Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("nonlinear_truss_test_local_stress_adjoint_parameters.json",'r') as parameter_file:
ProjectParametersAdjoint = Parameters( parameter_file.read())
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
def solve_primal_problem(file_name):
with open(file_name,'r') as parameter_file:
ProjectParametersPrimal = Parameters( parameter_file.read())
# To avoid many prints
if (ProjectParametersPrimal["problem_data"]["echo_level"].GetInt() == 0):
Logger.GetDefaultOutput().SetSeverity(Logger.Severity.WARNING)
model_primal = Model()
primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(model_primal, ProjectParametersPrimal)
primal_analysis.Run()
def __init__(self, identifier, response_settings, model):
self.identifier = identifier
with open(response_settings["primal_settings"].GetString()) as parameters_file:
ProjectParametersPrimal = Parameters(parameters_file.read())
self.primal_model_part = _GetModelPart(model, ProjectParametersPrimal["solver_settings"])
self.primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(model, ProjectParametersPrimal)
self.primal_model_part.AddNodalSolutionStepVariable(SHAPE_SENSITIVITY)
self.response_function_utility = StructuralMechanicsApplication.StrainEnergyResponseFunctionUtility(self.primal_model_part, response_settings)
def solve_primal_problem():
with open(
"./adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_parameters.json",
'r') as parameter_file:
ProjectParametersPrimal = Parameters(parameter_file.read())
# To avoid many prints
if (ProjectParametersPrimal["problem_data"]["echo_level"].GetInt() == 0):
Logger.GetDefaultOutput().SetSeverity(Logger.Severity.WARNING)
model_primal = Model()
primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model_primal, ProjectParametersPrimal)
primal_analysis.Run()
def setUp(self):
# Within this location context:
with controlledExecutionScope(
os.path.dirname(os.path.realpath(__file__))):
# Reading the ProjectParameters
with open(self.file_name + "_parameters.json",
'r') as parameter_file:
ProjectParameters = KratosMultiphysics.Parameters(
parameter_file.read())
# Creating the test
self.test = structural_mechanics_analysis.StructuralMechanicsAnalysis(
ProjectParameters)
self.test.Initialize()
def test_local_stress_response(self):
#Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("linear_truss_test_local_stress_adjoint_parameters.json",'r') as parameter_file:
ProjectParametersAdjoint = Parameters( parameter_file.read())
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
model_part_name = ProjectParametersAdjoint["solver_settings"]["model_part_name"].GetString()
reference_value = 0.7071067811865476
sensitivity_to_check = model_adjoint.GetModelPart(model_part_name).Conditions[1].GetValue(POINT_LOAD_SENSITIVITY)[1]
self.assertAlmostEqual(sensitivity_to_check, reference_value, 4)
def test_nodal_reaction_response(self):
# Create the adjoint solver
with controlledExecutionScope(_get_test_working_dir()):
with open("beam_test_nodal_reaction_adjoint_parameters.json",'r') as parameter_file:
ProjectParametersAdjoint = Parameters( parameter_file.read())
model_part_name = ProjectParametersAdjoint["solver_settings"]["model_part_name"].GetString()
model_adjoint = Model()
adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(model_adjoint, ProjectParametersAdjoint)
adjoint_analysis.Run()
# Check sensitivity for the parameter POINT_LOAD
reference_values = -0.31249774999397384
sensitivity_to_check = model_adjoint.GetModelPart(model_part_name).Conditions[1].GetValue(POINT_LOAD_SENSITIVITY)[2]
self.assertAlmostEqual(reference_values, sensitivity_to_check, 4)
def setUp(self):
# Within this location context:
with controlledExecutionScope(os.path.dirname(os.path.realpath(__file__))):
# Reading the ProjectParameters
with open(self.file_name + "_parameters.json",'r') as parameter_file:
ProjectParameters = KratosMultiphysics.Parameters(parameter_file.read())
self.modify_parameters(ProjectParameters)
# To avoid many prints
if (ProjectParameters["problem_data"]["echo_level"].GetInt() == 0):
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING)
# Creating the test
model = KratosMultiphysics.Model()
self.test = structural_mechanics_analysis.StructuralMechanicsAnalysis(model, ProjectParameters)
self.test.Initialize()
def __init__(self):
self.model = Kratos.Model()
import dem_main_script_ready_for_coupling_with_fem
self.dem_solution = dem_main_script_ready_for_coupling_with_fem.Solution(
self.model)
self.dem_solution.coupling_algorithm = weakref.proxy(self)
import structural_mechanics_analysis
structural_parameters_file_name = "ProjectParameters.json"
with open(structural_parameters_file_name, 'r') as parameter_file:
parameters = Kratos.Parameters(parameter_file.read())
# Create structural solver, main_model_part and added variables
self.structural_solution = structural_mechanics_analysis.StructuralMechanicsAnalysis(
self.model, parameters)
self.AddDEMVariablesToStructural()
def RunCoupledSystem():
## create structural analysis
model = KratosMultiphysics.Model()
with open("ProjectParameters.json", 'r') as parameter_file:
parameters = KratosMultiphysics.Parameters(parameter_file.read())
structural_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, parameters)
structural_analysis.Initialize()
print("-----> Initialized fem part")
## create dem analysis
model_dem = KratosMultiphysics.Model()
dem_analysis = main_script.Solution(model_dem)
dem_analysis.Initialize()
dem_analysis.InitializeTime()
print("-----> Initialized dem part")
## create model parts
mp_struct = model["Structure.computing_domain"]
mp_dem = dem_analysis.rigid_face_model_part.GetSubModelPart('1')
mp_dem_particle = dem_analysis.spheres_model_part
####################################################################### WALL
## create point load condition on all fem nodes
cond_counter = 0
node_id_list = []
for node_i in mp_struct.Nodes:
node_id = node_i.Id
node_id_list.append(node_id)
cond_counter += 1
mp_struct.CreateNewCondition("PointLoadCondition3D1N", cond_counter,
[node_id],
mp_struct.GetProperties()[0])
print("-----> Created fem PointLoadConditions")
## create structural submodal part used for mapping
struct_smp = mp_struct.CreateSubModelPart("struct_sub")
struct_smp.AddNodes(node_id_list)
## set up mapper
print("-----> Added node list for mapping part")
mapper_settings = KratosMultiphysics.Parameters("""{"mapper_settings":
{"mapper_type": "nearest_neighbor",
"interface_submodel_part_destination": "struct_sub",
"echo_level":1}}""")
print("-----> Wrote mapper settings")
mapper = KratosMapping.MapperFactory.CreateMapper(
mp_dem, mp_struct, mapper_settings["mapper_settings"])
print("-----> Initialized mapper")
dem_mesh_moving_utility = DEMApplication.MoveMeshUtility()
print("-----> Starting time loop:")
## run solving loop
while dem_analysis.time < dem_analysis.final_time:
print('current t: ', dem_analysis.time)
## call dem functions
dem_analysis.UpdateTimeParameters()
dem_analysis.BeforeSolveOperations(dem_analysis.time)
dem_analysis.SolverSolve()
dem_analysis.AfterSolveOperations()
dem_analysis.FinalizeSingleTimeStep()
## map loads
mapper.Map(DEMApplication.CONTACT_FORCES,
StructuralMechanicsApplication.POINT_LOAD)
## call fem functions
structural_analysis.time = structural_analysis._GetSolver(
).AdvanceInTime(structural_analysis.time)
structural_analysis.InitializeSolutionStep()
structural_analysis._GetSolver().Predict()
structural_analysis._GetSolver().SolveSolutionStep()
structural_analysis.FinalizeSolutionStep()
structural_analysis.OutputSolutionStep()
## map-1 vel,disp
mapper.InverseMap(KratosMultiphysics.VELOCITY,
KratosMultiphysics.VELOCITY)
mapper.InverseMap(KratosMultiphysics.DISPLACEMENT,
KratosMultiphysics.DISPLACEMENT)
## move dem wall mesh
dem_mesh_moving_utility.MoveDemMesh(mp_dem.Nodes, True)
dem_analysis.OutputSingleTimeLoop(
) ## do this at the end of the loop to see deformed net
## finalize dem
dem_analysis.Finalize()
dem_analysis.CleanUpOperations()
## finalize fem
structural_analysis.Finalize()
# Making KratosMultiphysics backward compatible with python 2.6 and 2.7
from __future__ import print_function, absolute_import, division
# Import Kratos core and apps
from KratosMultiphysics import *
from KratosMultiphysics.StructuralMechanicsApplication import *
import structural_mechanics_analysis
# Read parameters
with open("ProjectParameters.json", 'r') as parameter_file:
parameters = Parameters(parameter_file.read())
model = Model()
analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, parameters)
analysis.Run()
