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()