def _linear_interpolation(x, x_list, y_list): tb = KratosMultiphysics.PiecewiseLinearTable() for i in range(len(x_list)): tb.AddRow(x_list[i], y_list[i]) return tb.GetNearestValue(x)
def __init__(self, main_model_part, custom_settings): self.main_model_part = main_model_part ##settings string in json format contact_settings = KM.Parameters(""" { "contact_settings" : { "mortar_type" : "", "condn_convergence_criterion" : false, "fancy_convergence_criterion" : true, "print_convergence_criterion" : false, "ensure_contact" : false, "gidio_debug" : false, "adaptative_strategy" : false, "split_factor" : 10.0, "max_number_splits" : 3, "contact_displacement_relative_tolerance": 1.0e-4, "contact_displacement_absolute_tolerance": 1.0e-9, "contact_residual_relative_tolerance" : 1.0e-4, "contact_residual_absolute_tolerance" : 1.0e-9, "use_mixed_ulm_solver" : true, "mixed_ulm_solver_parameters" : { "solver_type": "mixed_ulm_linear_solver", "tolerance" : 1.0e-6, "max_iteration_number" : 200 } } } """) ## Overwrite the default settings with user-provided parameters self.settings = custom_settings self.validate_and_transfer_matching_settings(self.settings, contact_settings) self.contact_settings = contact_settings["contact_settings"] # Construct the base solver. super().__init__(self.main_model_part, self.settings) # Setting default configurations true by default if (self.settings["clear_storage"].GetBool() == False): self.print_on_rank_zero("Clear storage", "Storage must be cleared each step. Switching to True") self.settings["clear_storage"].SetBool(True) if (self.settings["reform_dofs_at_each_step"].GetBool() == False): self.print_on_rank_zero("Reform DoFs", "DoF must be reformed each time step. Switching to True") self.settings["reform_dofs_at_each_step"].SetBool(True) if (self.settings["block_builder"].GetBool() == False): self.print_on_rank_zero("Builder and solver", "EliminationBuilderAndSolver can not used with the current implementation. Switching to BlockBuilderAndSolver") self.settings["block_builder"].SetBool(True) # Setting echo level self.echo_level = self.settings["echo_level"].GetInt() # Initialize the processes list self.processes_list = None # Initialize the post process self.post_process = None self.print_on_rank_zero("::[Contact Mechanical Implicit Dynamic Solver]:: ", "Construction of ContactMechanicalSolver finished")
def test_MPMPointLoadCondition3D1N(self): current_model = KratosMultiphysics.Model() self._execute_point_load_condition_test(current_model, Dimension=3)
def _create_elements(self, initial_mp): initial_mp.CreateNewElement("UpdatedLagrangian3D8N", 1, [1,2,3,4,5,6,7,8], initial_mp.GetProperties()[1]) KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.ACTIVE, True, initial_mp.Elements)
def __init__(self, Model, custom_settings ): KratosMultiphysics.Process.__init__(self) ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "help" : "This process assigns a modulus and direction value to a vector variable", "model_part_name": "MODEL_PART_NAME", "variable_name": "VARIABLE_NAME", "modulus" : 0.0, "direction": [0.0, 0.0, 0.0], "constrained": false, "interval": [0.0, "End"], "local_axes" : {} } """) #trick to allow "value" to be a string or a double value if(custom_settings.Has("modulus")): if(custom_settings["modulus"].IsString()): default_settings["modulus"].SetString("0.0") ##overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) ##check if variable type is a vector self.var = KratosMultiphysics.KratosGlobals.GetVariable(self.settings["variable_name"].GetString()) if( not isinstance(self.var, KratosMultiphysics.Array1DVariable3) ): raise Exception("Variable type is incorrect. Must be a three-component vector.") ##check normalized direction direction = [] scalar_prod = 0 for i in range(0, self.settings["direction"].size() ): direction.append( self.settings["direction"][i].GetDouble() ) scalar_prod = scalar_prod + direction[i]*direction[i] norm = math.sqrt(scalar_prod) self.value = [] if( norm != 0.0 ): for j in direction: self.value.append( j/norm ) else: for j in direction: self.value.append(0.0) ## set the value self.value_is_numeric = False if self.settings["modulus"].IsNumber(): self.value_is_numeric = True modulus = self.settings["modulus"].GetDouble() for i in range(0, len(self.value)): self.value[i] *= modulus else: self.function_expression = self.settings["modulus"].GetString() counter = 0 for i in self.value: self.value[counter] = str(i) + "*(" + self.function_expression +")" counter+=1 ###set vector components process params = KratosMultiphysics.Parameters("{}") params.AddValue("model_part_name", self.settings["model_part_name"]) params.AddValue("variable_name", self.settings["variable_name"]) params.AddEmptyValue("value") params.__setitem__("value", self.settings["direction"]) counter = 0 for i in self.value: if( self.value_is_numeric ): params["value"][counter].SetDouble(i) else: params["value"][counter].SetString(i) counter+=1 params.AddValue("constrained", self.settings["constrained"]) params.AddValue("interval",self.settings["interval"]) params.AddValue("local_axes", self.settings["local_axes"]) BaseProcess.AssignVectorComponentsToNodesProcess.__init__(self, Model, params)
def _SetSlip(self): Kratos.VariableUtils().SetFlag(Kratos.SLIP, True, self.model_part.Nodes) Kratos.VariableUtils().SetFlag(Kratos.SLIP, True, self.model_part.Conditions)
def __init__(self, optimization_settings, analyzer, communicator, model_part_controller): default_algorithm_settings = KM.Parameters(""" { "name" : "penalized_projection", "max_correction_share" : 0.75, "max_iterations" : 100, "relative_tolerance" : 1e-3, "line_search" : { "line_search_type" : "manual_stepping", "normalize_search_direction" : true, "step_size" : 1.0 } }""") self.algorithm_settings = optimization_settings[ "optimization_algorithm"] self.algorithm_settings.RecursivelyValidateAndAssignDefaults( default_algorithm_settings) self.optimization_settings = optimization_settings self.mapper_settings = optimization_settings["design_variables"][ "filter"] self.analyzer = analyzer self.communicator = communicator self.model_part_controller = model_part_controller self.design_surface = None self.mapper = None self.data_logger = None self.optimization_utilities = None self.objectives = optimization_settings["objectives"] self.constraints = optimization_settings["constraints"] self.constraint_gradient_variables = {} for itr, constraint in enumerate(self.constraints): self.constraint_gradient_variables.update({ constraint["identifier"].GetString(): { "gradient": KM.KratosGlobals.GetVariable("DC" + str(itr + 1) + "DX"), "mapped_gradient": KM.KratosGlobals.GetVariable("DC" + str(itr + 1) + "DX_MAPPED") } }) self.max_correction_share = self.algorithm_settings[ "max_correction_share"].GetDouble() self.step_size = self.algorithm_settings["line_search"][ "step_size"].GetDouble() self.max_iterations = self.algorithm_settings["max_iterations"].GetInt( ) + 1 self.relative_tolerance = self.algorithm_settings[ "relative_tolerance"].GetDouble() self.optimization_model_part = model_part_controller.GetOptimizationModelPart( ) self.optimization_model_part.AddNodalSolutionStepVariable( KSO.SEARCH_DIRECTION) self.optimization_model_part.AddNodalSolutionStepVariable( KSO.CORRECTION)
def _ConstructSolver(self, builder_and_solver, scheme, convergence_criterion, strategy_type): nonlocal_damage = self.settings["mechanical_solver_settings"][ "nonlocal_damage"].GetBool() max_iters = self.settings["mechanical_solver_settings"][ "max_iteration"].GetInt() compute_reactions = self.settings["mechanical_solver_settings"][ "compute_reactions"].GetBool() reform_step_dofs = self.settings["mechanical_solver_settings"][ "reform_dofs_at_each_step"].GetBool() move_mesh_flag = self.settings["mechanical_solver_settings"][ "move_mesh_flag"].GetBool() if strategy_type == "Newton-Raphson": if nonlocal_damage: self.strategy_params = KratosMultiphysics.Parameters("{}") self.strategy_params.AddValue( "loads_sub_model_part_list", self.loads_sub_sub_model_part_list) self.strategy_params.AddValue( "loads_variable_list", self.settings["mechanical_solver_settings"] ["loads_variable_list"]) self.strategy_params.AddValue( "body_domain_sub_model_part_list", self.body_domain_sub_sub_model_part_list) self.strategy_params.AddValue( "characteristic_length", self.settings["mechanical_solver_settings"] ["characteristic_length"]) self.strategy_params.AddValue( "search_neighbours_step", self.settings["mechanical_solver_settings"] ["search_neighbours_step"]) solver = KratosPoro.PoromechanicsNewtonRaphsonNonlocalStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, self.strategy_params, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) else: self.main_model_part.ProcessInfo.SetValue( KratosPoro.IS_CONVERGED, True) solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) else: # Arc-Length strategy self.strategy_params = KratosMultiphysics.Parameters("{}") self.strategy_params.AddValue( "desired_iterations", self.settings["mechanical_solver_settings"] ["desired_iterations"]) self.strategy_params.AddValue( "max_radius_factor", self.settings["mechanical_solver_settings"] ["max_radius_factor"]) self.strategy_params.AddValue( "min_radius_factor", self.settings["mechanical_solver_settings"] ["min_radius_factor"]) self.strategy_params.AddValue("loads_sub_model_part_list", self.loads_sub_sub_model_part_list) self.strategy_params.AddValue( "loads_variable_list", self.settings["mechanical_solver_settings"] ["loads_variable_list"]) if nonlocal_damage: self.strategy_params.AddValue( "body_domain_sub_model_part_list", self.body_domain_sub_sub_model_part_list) self.strategy_params.AddValue( "characteristic_length", self.settings["mechanical_solver_settings"] ["characteristic_length"]) self.strategy_params.AddValue( "search_neighbours_step", self.settings["mechanical_solver_settings"] ["search_neighbours_step"]) solver = KratosPoro.PoromechanicsRammArcLengthNonlocalStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, self.strategy_params, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) else: solver = KratosPoro.PoromechanicsRammArcLengthStrategy( self.mechanical_computing_model_part, scheme, self.mechanical_linear_solver, convergence_criterion, builder_and_solver, self.strategy_params, max_iters, compute_reactions, reform_step_dofs, move_mesh_flag) return solver
def AddVariables(self): ## Mechanical Variables # Add displacements self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DISPLACEMENT) # Add reactions for the displacements self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.REACTION) # Add dynamic variables self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.VELOCITY) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.ACCELERATION) # Add variables for the solid conditions self.main_model_part.AddNodalSolutionStepVariable( KratosStructural.POINT_LOAD) self.main_model_part.AddNodalSolutionStepVariable(KratosDam.FORCE_LOAD) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.POSITIVE_FACE_PRESSURE) # Add volume acceleration self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.VOLUME_ACCELERATION) # Add variables for post-processing self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.NODAL_AREA) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.NODAL_CAUCHY_STRESS_TENSOR) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.INITIAL_NODAL_CAUCHY_STRESS_TENSOR) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.Vi_POSITIVE) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.Viii_POSITIVE) self.main_model_part.AddNodalSolutionStepVariable( KratosPoro.NODAL_JOINT_WIDTH) self.main_model_part.AddNodalSolutionStepVariable( KratosPoro.NODAL_JOINT_AREA) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.NODAL_YOUNG_MODULUS) ## Thermal variables thermal_settings = KratosMultiphysics.ConvectionDiffusionSettings() thermal_settings.SetDiffusionVariable(KratosMultiphysics.CONDUCTIVITY) thermal_settings.SetUnknownVariable(KratosMultiphysics.TEMPERATURE) thermal_settings.SetSpecificHeatVariable( KratosMultiphysics.SPECIFIC_HEAT) thermal_settings.SetDensityVariable(KratosMultiphysics.DENSITY) thermal_settings.SetVolumeSourceVariable(KratosMultiphysics.HEAT_FLUX) thermal_settings.SetSurfaceSourceVariable( KratosMultiphysics.FACE_HEAT_FLUX) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.CONVECTION_DIFFUSION_SETTINGS, thermal_settings) # Add thermal variables self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.CONDUCTIVITY) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.TEMPERATURE) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.SPECIFIC_HEAT) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DENSITY) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.HEAT_FLUX) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.FACE_HEAT_FLUX) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.NODAL_REFERENCE_TEMPERATURE) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.PLACEMENT_TEMPERATURE) # This Variable is used for computing heat source according Azenha Formulation self.main_model_part.AddNodalSolutionStepVariable( KratosDam.ALPHA_HEAT_SOURCE) self.main_model_part.AddNodalSolutionStepVariable( KratosDam.TIME_ACTIVATION) print("Variables correctly added")
def __init__(self, main_model_part, custom_settings): #TODO: shall obtain the computing_model_part from the MODEL once the object is implemented self.main_model_part = main_model_part ##settings string in json format default_settings = KratosMultiphysics.Parameters(""" { "solver_type": "dam_selfweight_solver", "model_import_settings":{ "input_type": "mdpa", "input_filename": "unknown_name", "input_file_label": 0 }, "echo_level": 0, "buffer_size": 2, "processes_sub_model_part_list": [""], "mechanical_solver_settings":{ "echo_level": 0, "reform_dofs_at_each_step": false, "clear_storage": false, "compute_reactions": false, "move_mesh_flag": true, "solution_type": "Quasi-Static", "scheme_type": "Newmark", "rayleigh_m": 0.0, "rayleigh_k": 0.0, "strategy_type": "Newton-Raphson", "convergence_criterion": "Displacement_criterion", "displacement_relative_tolerance": 1.0e-4, "displacement_absolute_tolerance": 1.0e-9, "residual_relative_tolerance": 1.0e-4, "residual_absolute_tolerance": 1.0e-9, "max_iteration": 15, "desired_iterations": 4, "max_radius_factor": 20.0, "min_radius_factor": 0.5, "block_builder": true, "nonlocal_damage": false, "characteristic_length": 0.05, "search_neighbours_step": false, "linear_solver_settings":{ "solver_type": "amgcl", "tolerance": 1.0e-6, "max_iteration": 100, "scaling": false, "verbosity": 0, "preconditioner_type": "ilu0", "smoother_type": "ilu0", "krylov_type": "gmres", "coarsening_type": "aggregation" }, "problem_domain_sub_model_part_list": [""], "body_domain_sub_model_part_list": [], "mechanical_loads_sub_model_part_list": [], "loads_sub_model_part_list": [], "loads_variable_list": [] } } """) # Overwrite the default settings with user-provided parameters self.settings = custom_settings self.settings.ValidateAndAssignDefaults(default_settings) # Construct the linear solver import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory self.mechanical_linear_solver = linear_solver_factory.ConstructSolver( self.settings["mechanical_solver_settings"] ["linear_solver_settings"]) print("Construction of DamSelfweightSolver finished")
def _ExecuteAfterReading(self): self.mechanical_model_part_name = "mechanical_computing_domain" self.body_domain_sub_sub_model_part_list = [] for i in range(self.settings["mechanical_solver_settings"] ["body_domain_sub_model_part_list"].size()): self.body_domain_sub_sub_model_part_list.append( "sub_" + self.settings["mechanical_solver_settings"] ["body_domain_sub_model_part_list"][i].GetString()) self.body_domain_sub_sub_model_part_list = KratosMultiphysics.Parameters( json.dumps(self.body_domain_sub_sub_model_part_list)) self.loads_sub_sub_model_part_list = [] for i in range(self.settings["mechanical_solver_settings"] ["loads_sub_model_part_list"].size()): self.loads_sub_sub_model_part_list.append( "sub_" + self.settings["mechanical_solver_settings"] ["loads_sub_model_part_list"][i].GetString()) self.loads_sub_sub_model_part_list = KratosMultiphysics.Parameters( json.dumps(self.loads_sub_sub_model_part_list)) # Auxiliary Kratos parameters object to be called by the CheckAndPepareModelProcess aux_params = KratosMultiphysics.Parameters("{}") aux_params.AddEmptyValue("mechanical_model_part_name").SetString( self.mechanical_model_part_name) aux_params.AddValue( "mechanical_domain_sub_model_part_list", self.settings["mechanical_solver_settings"] ["problem_domain_sub_model_part_list"]) aux_params.AddValue( "mechanical_loads_sub_model_part_list", self.settings["mechanical_solver_settings"] ["mechanical_loads_sub_model_part_list"]) aux_params.AddValue( "body_domain_sub_model_part_list", self.settings["mechanical_solver_settings"] ["body_domain_sub_model_part_list"]) aux_params.AddValue("body_domain_sub_sub_model_part_list", self.body_domain_sub_sub_model_part_list) aux_params.AddValue( "loads_sub_model_part_list", self.settings["mechanical_solver_settings"] ["loads_sub_model_part_list"]) aux_params.AddValue("loads_sub_sub_model_part_list", self.loads_sub_sub_model_part_list) # CheckAndPrepareModelProcess creates the solid_computational_model_part from KratosMultiphysics.DamApplication import check_and_prepare_selfweight_model_process_dam check_and_prepare_selfweight_model_process_dam.CheckAndPrepareSelfweightModelProcess( self.main_model_part, aux_params).Execute() # Constitutive law import from KratosMultiphysics.DamApplication import dam_constitutive_law_utility dam_constitutive_law_utility.SetConstitutiveLaw(self.main_model_part) self.main_model_part.SetBufferSize( self.settings["buffer_size"].GetInt()) minimum_buffer_size = self.GetMinimumBufferSize() if (minimum_buffer_size > self.main_model_part.GetBufferSize()): self.main_model_part.SetBufferSize(minimum_buffer_size)
"bathymetry_process_list", "initial_conditions_process_list", "boundary_conditions_process_list" ] def _GetSimulationName(self): return "Shallow Water Analysis" if __name__ == "__main__": from sys import argv if len(argv) > 2: err_msg = 'Too many input arguments!\n' err_msg += 'Use this script in the following way:\n' err_msg += '- With default ProjectParameters (read from "ProjectParameters.json"):\n' err_msg += ' "python3 shallow_water_analysis.py"\n' err_msg += '- With custom ProjectParameters:\n' err_msg += ' "python3 shallow_water_analysis.py CustomProjectParameters.json"\n' raise Exception(err_msg) if len(argv) == 2: # ProjectParameters is being passed from outside project_parameters_file_name = argv[1] else: # using default name project_parameters_file_name = "ProjectParameters.json" with open(project_parameter_file_name, 'r') as parameter_file: parameters = Kratos.Parameters(parameter_file.read()) model = Kratos.Model() ShallowWaterAnalysis(model, parameters).Run()
def testLineOutputProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "LineOutputProcess", "Parameters" : { "model_part_name" : "FluidModelPart", "variable_names_list" : ["DENSITY", "VELOCITY"], "historical_value" : true, "start_point" : [-0.09, 0.01, 0.0], "end_point" : [0.19, 0.01, 0.0], "number_of_sampling_points" : 100, "output_file_name" : "process_tests_data/line_output_test_output_historical", "output_step_control_variable_name" : "STEP", "output_step_interval" : 1, "write_header_information" : false } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "LineOutputProcess", "Parameters" : { "model_part_name" : "FluidModelPart", "variable_names_list" : [ "DENSITY", "VELOCITY", "EXTERNAL_FORCES_VECTOR", "GREEN_LAGRANGE_STRAIN_TENSOR"], "historical_value" : false, "start_point" : [-0.09, 0.01, 0.0], "end_point" : [0.19, 0.01, 0.0], "number_of_sampling_points" : 100, "output_file_name" : "process_tests_data/line_output_test_output_non_historical", "output_step_control_variable_name" : "STEP", "output_step_interval" : 1, "write_header_information" : false } }, { "kratos_module" : "KratosMultiphysics", "python_module" : "compare_two_files_check_process", "Parameters" : { "reference_file_name" : "process_tests_data/line_output_test_output_historical_ref.csv", "output_file_name" : "process_tests_data/line_output_test_output_historical_1.000000.csv", "remove_output_file" : true, "comparison_type" : "csv_file", "tolerance" : 1e-6, "relative_tolerance" : 1e-9, "dimension" : 3 } }, { "kratos_module" : "KratosMultiphysics", "python_module" : "compare_two_files_check_process", "Parameters" : { "reference_file_name" : "process_tests_data/line_output_test_output_non_historical_ref.csv", "output_file_name" : "process_tests_data/line_output_test_output_non_historical_1.000000.csv", "remove_output_file" : true, "comparison_type" : "csv_file", "tolerance" : 1e-6, "relative_tolerance" : 1e-9, "dimension" : 3 } } ]''') KratosRANS.RansTestUtilities.RandomFillNodalNonHistoricalVariable( self.model_part, Kratos.DENSITY, 0.0, 50.0) KratosRANS.RansTestUtilities.RandomFillNodalNonHistoricalVariable( self.model_part, Kratos.VELOCITY, 0.0, 50.0) for node in self.model_part.Nodes: v = Kratos.Vector(4) v[0] = node.X v[1] = node.Y v[2] = node.GetValue(Kratos.DENSITY) v[3] = node.GetValue(Kratos.DENSITY) * 1.1 node.SetValue(Kratos.EXTERNAL_FORCES_VECTOR, v) m = Kratos.Matrix(2, 2) m[0, 0] = node.GetValue(Kratos.DENSITY) m[0, 1] = node.GetValue(Kratos.VELOCITY)[0] m[1, 0] = node.GetValue(Kratos.VELOCITY)[1] m[1, 1] = node.GetValue(Kratos.VELOCITY)[2] node.SetValue(Kratos.GREEN_LAGRANGE_STRAIN_TENSOR, m) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def EvaluateQuantityOfInterest(self): ############################################################################################## # Functions evaluating the QoI of the problem: Array of displacement at every node on the mesh # # and nodal area # ############################################################################################## ArrayOfDisplacements = [] for node in self._GetSolver().GetComputingModelPart().Nodes: ArrayOfDisplacements.append(node.GetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_X, 0)) ArrayOfDisplacements.append(node.GetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Y, 0)) return ArrayOfDisplacements def EvaluateQuantityOfInterest2(self): computing_model_part = self._solver.GetComputingModelPart() dimension = self._GetSolver().settings["domain_size"].GetInt() area_calculator = KratosMultiphysics.CalculateNodalAreaProcess(computing_model_part , dimension) area_calculator.Execute() ArrayOfAreas = [] for node in self._GetSolver().GetComputingModelPart().Nodes: ArrayOfAreas.append(node.GetSolutionStepValue(KratosMultiphysics.NODAL_AREA)) ArrayOfAreas.append(node.GetSolutionStepValue(KratosMultiphysics.NODAL_AREA)) return ArrayOfAreas if __name__ == "__main__": with open("ProjectParametersROM.json",'r') as parameter_file: parameters = KratosMultiphysics.Parameters(parameter_file.read()) model = KratosMultiphysics.Model() Simulation = TestStructuralMechanicsStaticROM(model,parameters) Simulation.Run()
def testCalculateFirstDerivativesLHS(self): analytical_sensitivity = Kratos.Matrix() self.adjoint_condition.CalculateFirstDerivativesLHS(analytical_sensitivity, self.model_part.ProcessInfo) self._assertMatrixAlmostEqual(Kratos.Matrix(6, 6, 0), analytical_sensitivity, 9)
def _CreateScheme(self): domain_size = self.GetComputingModelPart().ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] # Cases in which the element manages the time integration if self.element_integrates_in_time: # "Fake" scheme for those cases in where the element manages the time integration # It is required to perform the nodal update once the current time step is solved scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip( domain_size, domain_size + 1) # In case the BDF2 scheme is used inside the element, the BDF time discretization utility is required to update the BDF coefficients if (self.settings["time_scheme"].GetString() == "bdf2"): time_order = 2 self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF( time_order) else: err_msg = "Requested elemental time scheme \"" + self.settings[ "time_scheme"].GetString() + "\" is not available.\n" err_msg += "Available options are: \"bdf2\"" raise Exception(err_msg) # Cases in which a time scheme manages the time integration else: # Time scheme without turbulence modelling if not hasattr(self, "_turbulence_model_solver"): # Bossak time integration scheme if self.settings["time_scheme"].GetString() == "bossak": if self.settings["consider_periodic_conditions"].GetBool( ) == True: scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent( self.settings["alpha"].GetDouble(), domain_size, KratosCFD.PATCH_INDEX) else: scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent( self.settings["alpha"].GetDouble(), self.settings["move_mesh_strategy"].GetInt(), domain_size) # BDF2 time integration scheme elif self.settings["time_scheme"].GetString() == "bdf2": scheme = KratosCFD.GearScheme() # Time scheme for steady state fluid solver elif self.settings["time_scheme"].GetString() == "steady": scheme = KratosCFD.ResidualBasedSimpleSteadyScheme( self.settings["velocity_relaxation"].GetDouble(), self.settings["pressure_relaxation"].GetDouble(), domain_size) else: err_msg = "Requested time scheme " + self.settings[ "time_scheme"].GetString() + " is not available.\n" err_msg += "Available options are: \"bossak\", \"bdf2\" and \"steady\"" raise Exception(err_msg) # Time scheme with turbulence modelling else: self._turbulence_model_solver.Initialize() if self.settings["time_scheme"].GetString() == "bossak": scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent( self.settings["alpha"].GetDouble(), self.settings["move_mesh_strategy"].GetInt(), domain_size, self.settings["turbulence_model_solver_settings"] ["velocity_pressure_relaxation_factor"].GetDouble(), self._turbulence_model_solver. GetTurbulenceSolvingProcess()) # Time scheme for steady state fluid solver elif self.settings["time_scheme"].GetString() == "steady": scheme = KratosCFD.ResidualBasedSimpleSteadyScheme( self.settings["velocity_relaxation"].GetDouble(), self.settings["pressure_relaxation"].GetDouble(), domain_size, self._turbulence_model_solver. GetTurbulenceSolvingProcess()) return scheme
def testCalculateFirstDerivativesLHSSlip(self): self._SetSlip() analytical_sensitivity = Kratos.Matrix() self.adjoint_condition.CalculateFirstDerivativesLHS(analytical_sensitivity, self.model_part.ProcessInfo) fd_sensitivity = self._ComputeFiniteDifferenceSensitivity([Kratos.VELOCITY, Kratos.PRESSURE], 1e-7) self._assertMatrixAlmostEqual(fd_sensitivity, analytical_sensitivity, 9)
def test_eigen_with_constraints(self): analysis_parameters_scipy = KratosMultiphysics.Parameters("""{ "problem_data" : { "parallel_type" : "OpenMP", "echo_level" : 1, "start_time" : 0.0, "end_time" : 1.0 }, "solver_settings" : { "solver_type" : "KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_custom_scipy_base_solver", "model_part_name" : "Structure", "domain_size" : 3, "model_import_settings" : { "input_type" : "use_input_model_part" }, "time_stepping" : { "time_step" : 1.1 }, "use_computing_model_part" : false, "rotation_dofs" : true, "block_builder" : false } }""") analysis_parameters_eigen = KratosMultiphysics.Parameters("""{ "problem_data" : { "parallel_type" : "OpenMP", "echo_level" : 1, "start_time" : 0.0, "end_time" : 1.0 }, "solver_settings" : { "solver_type" : "eigen_value", "model_part_name" : "Structure", "domain_size" : 3, "model_import_settings" : { "input_type" : "use_input_model_part" }, "time_stepping" : { "time_step" : 1.1 }, "use_computing_model_part" : false, "rotation_dofs" : true, "block_builder" : true, "eigensolver_settings" : { "solver_type" : "eigen_eigensystem", "number_of_eigenvalues" : 5, "normalize_eigenvectors": true, "max_iteration" : 10000, "tolerance" : 1e-6 } } }""") model_scipy = KratosMultiphysics.Model() analysis_scipy = StructuralMechanicsAnalysis( model_scipy, analysis_parameters_scipy.Clone()) model_part_scipy = model_scipy["Structure"] SetupSystem(model_part_scipy) analysis_scipy.Run() model_eigen = KratosMultiphysics.Model() analysis_eigen = StructuralMechanicsAnalysis( model_eigen, analysis_parameters_eigen.Clone()) model_part_eigen = model_eigen["Structure"] SetupSystem(model_part_eigen) analysis_eigen.Run() self.__CompareEigenSolution(model_part_scipy, model_part_eigen)
def __init__(self, Model, settings): """ The default constructor of the class Keyword arguments: self -- It signifies an instance of a class. Model -- the container of the different model parts. settings -- Kratos parameters containing solver settings. """ KratosMultiphysics.Process.__init__(self) default_settings = KratosMultiphysics.Parameters(""" { "help" : "This process sets a variable a certain scalar value in a given direction, for all the nodes belonging to a submodelpart. Uses assign_scalar_variable_to_conditions_process for each component", "mesh_id" : 0, "model_part_name" : "please_specify_model_part_name", "variable_name" : "SPECIFY_VARIABLE_NAME", "interval" : [0.0, 1e30], "modulus" : 1.0, "constrained" : true, "direction" : [1.0, 0.0, 0.0], "local_axes" : {} } """) # Trick: allow "modulus" and "direction" to be a double or a string value (otherwise the ValidateAndAssignDefaults might fail) if settings.Has("modulus"): if settings["modulus"].IsString(): default_settings["modulus"].SetString("0.0") if settings.Has("direction"): if settings["direction"].IsString(): default_settings["direction"].SetString("Automatic") # Detect "End" as a tag and replace it by a large number if settings.Has("interval"): if settings["interval"][1].IsString(): if settings["interval"][1].GetString() == "End": settings["interval"][1].SetDouble( 1e30) # = default_settings["interval"][1] else: raise Exception( "The second value of interval can be \"End\" or a number, interval currently:" + settings["interval"].PrettyPrintJsonString()) settings.ValidateAndAssignDefaults(default_settings) self.model_part = Model[settings["model_part_name"].GetString()] # Construct the component by component parameter objects x_params = KratosMultiphysics.Parameters("{}") y_params = KratosMultiphysics.Parameters("{}") z_params = KratosMultiphysics.Parameters("{}") list_params = [x_params, y_params, z_params] for i_dir, var_string in enumerate(["_X", "_Y", "_Z"]): list_params[i_dir].AddValue("model_part_name", settings["model_part_name"]) list_params[i_dir].AddValue("mesh_id", settings["mesh_id"]) list_params[i_dir].AddValue("constrained", settings["constrained"]) list_params[i_dir].AddValue("interval", settings["interval"]) list_params[i_dir].AddEmptyValue("variable_name").SetString( settings["variable_name"].GetString() + var_string) list_params[i_dir].AddValue("local_axes", settings["local_axes"]) # "Automatic" direction: get the inwards direction all_numeric = True if settings["direction"].IsString(): if settings["direction"].GetString( ) == "automatic_inwards_normal" or settings["direction"].GetString( ) == "automatic_outwards_normal": # Compute the condition normals KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex( self.model_part, self.model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE]) # Compute the average conditions normal in the submodelpart of interest avg_normal = KratosMultiphysics.VariableUtils( ).SumConditionVectorVariable(KratosMultiphysics.NORMAL, self.model_part) avg_normal_norm = math.sqrt( pow(avg_normal[0], 2) + pow(avg_normal[1], 2) + pow(avg_normal[2], 2)) if avg_normal_norm < 1.0e-12: raise Exception( "Direction norm is close to 0 in AssignVectorByDirectionProcess." ) unit_direction = KratosMultiphysics.Vector(3) unit_direction = (1.0 / avg_normal_norm) * avg_normal # Note that the NormalCalculationUtils().CalculateOnSimplex gives the outwards normal vector if settings["direction"].GetString( ) == "automatic_inwards_normal": unit_direction = (-1) * unit_direction # Direction is given as a vector elif settings["direction"].IsArray(): unit_direction = [0.0, 0.0, 0.0] direction_norm = 0.0 for i in range(0, 3): if settings["direction"][i].IsNumber(): unit_direction[i] = settings["direction"][i].GetDouble() direction_norm += pow(unit_direction[i], 2) else: function_string = settings["direction"][i].GetString() unit_direction[i] = function_string all_numeric = False # Normalize direction if all_numeric: direction_norm = math.sqrt(direction_norm) if direction_norm < 1.0e-12: raise Exception( "Direction norm is close to 0 in AssignVectorByDirectionProcess." ) for i in range(0, 3): unit_direction[i] = unit_direction[i] / direction_norm # Set the remainding parameters if settings["modulus"].IsNumber(): modulus = settings["modulus"].GetDouble() if all_numeric: for i_dir in range(3): list_params[i_dir].AddEmptyValue("value").SetDouble( modulus * unit_direction[i_dir]) else: for i_dir in range(3): list_params[i_dir].AddEmptyValue( "value").SetString("(" + str(unit_direction[i_dir]) + ")*(" + str(modulus) + ")") elif settings["modulus"].IsString(): # The concatenated string is: "direction[i])*(f(x,y,z,t)" modulus = settings["modulus"].GetString() for i_dir in range(3): list_params[i_dir].AddEmptyValue("value").SetString( "(" + str(unit_direction[i_dir]) + ")*(" + modulus + ")") # Construct a AssignScalarToNodesProcess for each component self.aux_processes = [] for i_dir in range(3): self.aux_processes.append( assign_scalar_variable_process.AssignScalarVariableProcess( Model, list_params[i_dir]))
from __future__ import print_function, absolute_import, division # makes KratosMultiphysics backward compatible with python 2.6 and 2.7 # Importing the Kratos Library import KratosMultiphysics # Check that applications were imported in the main script KratosMultiphysics.CheckRegisteredApplications( "StructuralMechanicsApplication") # Import applications import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication # Convergence criteria class class convergence_criterion: def __init__(self, convergence_criterion_parameters): # Note that all the convergence settings are introduced via a Kratos parameters object. D_RT = convergence_criterion_parameters[ "displacement_relative_tolerance"].GetDouble() D_AT = convergence_criterion_parameters[ "displacement_absolute_tolerance"].GetDouble() R_RT = convergence_criterion_parameters[ "residual_relative_tolerance"].GetDouble() R_AT = convergence_criterion_parameters[ "residual_absolute_tolerance"].GetDouble() echo_level = convergence_criterion_parameters["echo_level"].GetInt() convergence_crit = convergence_criterion_parameters[ "convergence_criterion"].GetString()
def __init__(self, Model, settings): KratosMultiphysics.Process.__init__(self) default_settings = KratosMultiphysics.Parameters(""" { "mesh_id" : 0, "model_part_name" : "please_specify_model_part_name", "variable_name" : "SPECIFY_VARIABLE_NAME", "interval" : [0.0, 1e30], "value" : 0.0, "tolerance_rank" : 3, "local_axes" : {} } """) #detect "End" as a tag and replace it by a large number if (settings.Has("interval")): if (settings["interval"][1].IsString()): if (settings["interval"][1].GetString() == "End"): settings["interval"][1].SetDouble( 1e30) # = default_settings["interval"][1] else: raise Exception( "the second value of interval can be \"End\" or a number, interval currently:" + settings["interval"].PrettyPrintJsonString()) #here i do a trick, since i want to allow "value" to be a string or a double value if (settings.Has("value")): if (settings["value"].IsString()): default_settings["value"].SetString("0.0") settings.ValidateAndAssignDefaults(default_settings) #admissible values for local axes, are "empty" or #"local_axes" :{ # "origin" : [0.0, 0.0, 0.0] # "axes" : [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ] # } self.non_trivial_local_system = False if (settings["local_axes"].Has("origin")): # not empty self.non_trivial_local_system = True self.R = KratosMultiphysics.Matrix(3, 3) self.R[0, 0] = settings["local_axes"]["axes"][0][0].GetDouble() self.R[0, 1] = settings["local_axes"]["axes"][0][1].GetDouble() self.R[0, 2] = settings["local_axes"]["axes"][0][2].GetDouble() self.R[1, 0] = settings["local_axes"]["axes"][1][0].GetDouble() self.R[1, 1] = settings["local_axes"]["axes"][1][1].GetDouble() self.R[1, 2] = settings["local_axes"]["axes"][1][2].GetDouble() self.R[2, 0] = settings["local_axes"]["axes"][2][0].GetDouble() self.R[2, 1] = settings["local_axes"]["axes"][2][1].GetDouble() self.R[2, 2] = settings["local_axes"]["axes"][2][2].GetDouble() self.x0 = KratosMultiphysics.Vector(3) self.x0[0] = settings["local_axes"]["origin"][0].GetDouble() self.x0[1] = settings["local_axes"]["origin"][1].GetDouble() self.x0[2] = settings["local_axes"]["origin"][2].GetDouble() self.model_part = Model[settings["model_part_name"].GetString()] self.variable = getattr(KratosMultiphysics, settings["variable_name"].GetString()) self.mesh = self.model_part.GetMesh(settings["mesh_id"].GetInt()) self.interval = KratosMultiphysics.Vector(2) self.interval[0] = settings["interval"][0].GetDouble() self.interval[1] = settings["interval"][1].GetDouble() self.value_is_numeric = False self.is_time_function = False if settings["value"].IsNumber(): self.value_is_numeric = True self.value = settings["value"].GetDouble() else: self.function_string = settings["value"].GetString() if (sys.version_info > (3, 0)): self.aux_function = aux_object_cpp_callback( compile(self.function_string, '', 'eval', optimize=2)) else: self.aux_function = aux_object_cpp_callback( compile(self.function_string, '', 'eval')) if (self.function_string.find("x") == -1 and self.function_string.find("y") == -1 and self.function_string.find("z") == -1): #depends on time alone! self.is_time_function = True # Error tolerance self.tol = settings["tolerance_rank"].GetInt()
def __init__(self, convergence_criterion_parameters): # Note that all the convergence settings are introduced via a Kratos parameters object. D_RT = convergence_criterion_parameters[ "displacement_relative_tolerance"].GetDouble() D_AT = convergence_criterion_parameters[ "displacement_absolute_tolerance"].GetDouble() R_RT = convergence_criterion_parameters[ "residual_relative_tolerance"].GetDouble() R_AT = convergence_criterion_parameters[ "residual_absolute_tolerance"].GetDouble() echo_level = convergence_criterion_parameters["echo_level"].GetInt() convergence_crit = convergence_criterion_parameters[ "convergence_criterion"].GetString() if (echo_level >= 1): KratosMultiphysics.Logger.PrintInfo( "::[Mechanical Solver]:: ", "CONVERGENCE CRITERION : " + convergence_criterion_parameters["convergence_criterion"]. GetString()) rotation_dofs = False if (convergence_criterion_parameters.Has("rotation_dofs")): if (convergence_criterion_parameters["rotation_dofs"].GetBool()): rotation_dofs = True # Convergence criteria if there are rotation DOFs in the problem if (rotation_dofs is True): if (convergence_crit == "displacement_criterion"): self.mechanical_convergence_criterion = StructuralMechanicsApplication.DisplacementAndOtherDoFCriteria( D_RT, D_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_crit == "residual_criterion"): self.mechanical_convergence_criterion = StructuralMechanicsApplication.ResidualDisplacementAndOtherDoFCriteria( R_RT, R_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_crit == "and_criterion"): Displacement = StructuralMechanicsApplication.DisplacementAndOtherDoFCriteria( D_RT, D_AT) Displacement.SetEchoLevel(echo_level) Residual = StructuralMechanicsApplication.ResidualDisplacementAndOtherDoFCriteria( R_RT, R_AT) Residual.SetEchoLevel(echo_level) self.mechanical_convergence_criterion = KratosMultiphysics.AndCriteria( Residual, Displacement) elif (convergence_crit == "or_criterion"): Displacement = StructuralMechanicsApplication.DisplacementAndOtherDoFCriteria( D_RT, D_AT) Displacement.SetEchoLevel(echo_level) Residual = StructuralMechanicsApplication.ResidualDisplacementAndOtherDoFCriteria( R_RT, R_AT) Residual.SetEchoLevel(echo_level) self.mechanical_convergence_criterion = KratosMultiphysics.OrCriteria( Residual, Displacement) else: err_msg = "The requested convergence criterion \"" + convergence_crit + "\" is not available!\n" err_msg += "Available options are: \"displacement_criterion\", \"residual_criterion\", \"and_criterion\", \"or_criterion\"" raise Exception(err_msg) # Convergence criteria without rotation DOFs else: if (convergence_crit == "displacement_criterion"): self.mechanical_convergence_criterion = KratosMultiphysics.DisplacementCriteria( D_RT, D_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_crit == "residual_criterion"): self.mechanical_convergence_criterion = KratosMultiphysics.ResidualCriteria( R_RT, R_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_crit == "and_criterion"): Displacement = KratosMultiphysics.DisplacementCriteria( D_RT, D_AT) Displacement.SetEchoLevel(echo_level) Residual = KratosMultiphysics.ResidualCriteria(R_RT, R_AT) Residual.SetEchoLevel(echo_level) self.mechanical_convergence_criterion = KratosMultiphysics.AndCriteria( Residual, Displacement) elif (convergence_crit == "or_criterion"): Displacement = KratosMultiphysics.DisplacementCriteria( D_RT, D_AT) Displacement.SetEchoLevel(echo_level) Residual = KratosMultiphysics.ResidualCriteria(R_RT, R_AT) Residual.SetEchoLevel(echo_level) self.mechanical_convergence_criterion = KratosMultiphysics.OrCriteria( Residual, Displacement) else: err_msg = "The requested convergence criterion \"" + convergence_crit + "\" is not available!\n" err_msg += "Available options are: \"displacement_criterion\", \"residual_criterion\", \"and_criterion\", \"or_criterion\, \"adaptative_remesh_criteria\"" raise Exception(err_msg)
def _create_conditions(self, initial_mp): initial_mp.CreateNewCondition("Condition3D4N", 1, [2,4,8,6], initial_mp.GetProperties()[1]) KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.BOUNDARY, True, initial_mp.Conditions) for condition in initial_mp.Conditions: condition.SetValue(KratosParticle.PARTICLES_PER_CONDITION, 0)
import os # Import kratos core and applications import KratosMultiphysics import KratosMultiphysics.DelaunayMeshingApplication as KratosPfemg import KratosMultiphysics.PfemFluidDynamicsApplication as KratosPfemFluid ###################################################################################### ###################################################################################### ###################################################################################### #### PARSING THE PARAMETERS #### # Import input parameter_file = open("ProjectParameters.json",'r') ProjectParameters = KratosMultiphysics.Parameters(parameter_file.read()) #set echo level echo_level = ProjectParameters["problem_data"]["echo_level"].GetInt() print(" ") # defining the number of threads: threads = ProjectParameters["problem_data"]["threads"].GetInt() SetParallelSize(threads) num_threads = GetParallelSize() print("::[KPFEM Simulation]:: [OMP USING",num_threads,"THREADS ]") #parallel.PrintOMPInfo() print(" ")
from __future__ import print_function, absolute_import, division # makes KM backward compatible with python 2.6 and 2.7 #import kratos core and applications import KratosMultiphysics as KM import KratosMultiphysics.StructuralMechanicsApplication as SMA import KratosMultiphysics.ContactStructuralMechanicsApplication as CSMA # Check that KM was imported in the main script KM.CheckForPreviousImport() # Import the implicit solver (the explicit one is derived from it) import structural_mechanics_implicit_dynamic_solver def CreateSolver(main_model_part, custom_settings): return ImplicitMechanicalSolver(main_model_part, custom_settings) class ImplicitMechanicalSolver(structural_mechanics_implicit_dynamic_solver.ImplicitMechanicalSolver): """The structural mechanics contact implicit dynamic solver. This class creates the mechanical solvers for contact implicit dynamic analysis. It currently supports Newmark, Bossak and dynamic relaxation schemes. Public member variables: dynamic_settings -- settings for the implicit dynamic solvers. See structural_mechanics_solver.py for more information. """ def __init__(self, main_model_part, custom_settings): self.main_model_part = main_model_part ##settings string in json format
def _create_solution_scheme(self): return KratosMultiphysics.ResidualBasedAdjointStaticScheme( self.response_function)
from __future__ import print_function, absolute_import, division #makes KratosMultiphysics backward compatible with python 2.6 and 2.7 # importing the Kratos Library import KratosMultiphysics import KratosMultiphysics.ShallowWaterApplication as KratosShallow # Check that KratosMultiphysics was imported in the main script KratosMultiphysics.CheckForPreviousImport() ## Import base class file import shallow_water_base_solver def CreateSolver(model_part, custom_settings): return EulerianConservedVarSolver(model_part, custom_settings) class EulerianConservedVarSolver(shallow_water_base_solver.ShallowWaterBaseSolver): def AddVariables(self): super(EulerianConservedVarSolver,self).AddVariables() self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.MOMENTUM) def AddDofs(self): super(EulerianConservedVarSolver,self)._AddConservedDofs() def Solve(self): # If a node and it's neighbours are dry, set ACTIVE flag to false (self.ShallowVariableUtils).SetDryWetState() # Solve equations (self.solver).Solve() # Compute free surface (self.ShallowVariableUtils).ComputeFreeSurfaceElevation() # Compute velocity (self.ShallowVariableUtils).ComputeVelocity()
def testCalculateSensitivityMatrixSlip(self): self._SetSlip() analytical_sensitivity = Kratos.Matrix() self.adjoint_condition.CalculateSensitivityMatrix(Kratos.SHAPE_SENSITIVITY, analytical_sensitivity, self.model_part.ProcessInfo) fd_sensitivity = self._ComputeFiniteDifferenceSensitivity([Kratos.SHAPE_SENSITIVITY], 1e-7) self._assertMatrixAlmostEqual(fd_sensitivity, analytical_sensitivity, 9)
def _execute_point_load_condition_test(self, current_model, Dimension): mp = current_model.CreateModelPart("solid_part") mp.SetBufferSize(2) mp.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT) mp.AddNodalSolutionStepVariable(KratosMultiphysics.REACTION) mp.AddNodalSolutionStepVariable(KratosParticle.POINT_LOAD) # Create node node = mp.CreateNewNode(1, 0.0, 0.0, 0.0) # Ensure that the property 1 is created mp.GetProperties()[1] KratosMultiphysics.VariableUtils().AddDof( KratosMultiphysics.DISPLACEMENT_X, KratosMultiphysics.REACTION_X, mp) KratosMultiphysics.VariableUtils().AddDof( KratosMultiphysics.DISPLACEMENT_Y, KratosMultiphysics.REACTION_Y, mp) KratosMultiphysics.VariableUtils().AddDof( KratosMultiphysics.DISPLACEMENT_Z, KratosMultiphysics.REACTION_Z, mp) if Dimension == 2: cond = mp.CreateNewCondition("MPMPointLoadCondition2D1N", 1, [1], mp.GetProperties()[1]) elif Dimension == 3: cond = mp.CreateNewCondition("MPMPointLoadCondition3D1N", 1, [1], mp.GetProperties()[1]) else: raise RuntimeError("Wrong Dimension") lhs = KratosMultiphysics.Matrix(0, 0) rhs = KratosMultiphysics.Vector(0) # First we apply a load to the condition load_on_cond = KratosMultiphysics.Vector(3) load_on_cond[0] = 1.8 load_on_cond[1] = 2.6 load_on_cond[2] = -11.47 cond.SetValue(KratosParticle.POINT_LOAD, load_on_cond) cond.CalculateLocalSystem(lhs, rhs, mp.ProcessInfo) self.assertEqual(rhs[0], load_on_cond[0]) self.assertEqual(rhs[1], load_on_cond[1]) if Dimension == 3: self.assertEqual(rhs[2], load_on_cond[2]) # Now we apply a load to the node nodal_load = KratosMultiphysics.Vector(3) nodal_load[0] = -5.5 nodal_load[1] = 1.2 nodal_load[2] = 9.3 node.SetSolutionStepValue(KratosParticle.POINT_LOAD, nodal_load) cond.CalculateLocalSystem(lhs, rhs, mp.ProcessInfo) self.assertEqual(rhs[0], load_on_cond[0] + nodal_load[0]) self.assertEqual(rhs[1], load_on_cond[1] + nodal_load[1]) if Dimension == 3: self.assertEqual(rhs[2], load_on_cond[2] + nodal_load[2])
def _CreateMetricsProcess(self): self.metric_processes = [] if self.strategy == "LevelSet": level_set_parameters = KratosMultiphysics.Parameters("""{}""") level_set_parameters.AddValue("minimal_size", self.settings["minimal_size"]) level_set_parameters.AddValue("enforce_current", self.settings["enforce_current"]) level_set_parameters.AddValue( "anisotropy_remeshing", self.settings["anisotropy_remeshing"]) level_set_parameters.AddValue( "anisotropy_parameters", self.settings["anisotropy_parameters"]) level_set_parameters["anisotropy_parameters"].RemoveValue( "boundary_layer_min_size_ratio") if self.dim == 2: self.metric_processes.append( MeshingApplication.ComputeLevelSetSolMetricProcess2D( self.model_part, self.gradient_variable, level_set_parameters)) else: self.metric_processes.append( MeshingApplication.ComputeLevelSetSolMetricProcess3D( self.model_part, self.gradient_variable, level_set_parameters)) elif self.strategy == "Hessian": hessian_parameters = KratosMultiphysics.Parameters("""{}""") hessian_parameters.AddValue("minimal_size", self.settings["minimal_size"]) hessian_parameters.AddValue("maximal_size", self.settings["maximal_size"]) hessian_parameters.AddValue("enforce_current", self.settings["enforce_current"]) hessian_parameters.AddValue( "hessian_strategy_parameters", self.settings["hessian_strategy_parameters"]) hessian_parameters["hessian_strategy_parameters"].RemoveValue( "metric_variable") hessian_parameters.AddValue("anisotropy_remeshing", self.settings["anisotropy_remeshing"]) hessian_parameters.AddValue("anisotropy_parameters", self.settings["anisotropy_parameters"]) hessian_parameters["anisotropy_parameters"].RemoveValue( "boundary_layer_min_size_ratio") for current_metric_variable in self.metric_variable: if type(current_metric_variable ) is KratosMultiphysics.Array1DComponentVariable: if self.dim == 2: self.metric_processes.append( MeshingApplication. ComputeHessianSolMetricProcessComp2D( self.model_part, current_metric_variable, hessian_parameters)) else: self.metric_processes.append( MeshingApplication. ComputeHessianSolMetricProcessComp3D( self.model_part, current_metric_variable, hessian_parameters)) else: if self.dim == 2: self.metric_processes.append( MeshingApplication. ComputeHessianSolMetricProcess2D( self.model_part, current_metric_variable, hessian_parameters)) else: self.metric_processes.append( MeshingApplication. ComputeHessianSolMetricProcess3D( self.model_part, current_metric_variable, hessian_parameters)) elif self.strategy == "superconvergent_patch_recovery": if not structural_dependencies: raise Exception( "You need to compile the StructuralMechanicsApplication in order to use this criteria" ) # We compute the error error_compute_parameters = KratosMultiphysics.Parameters("""{}""") error_compute_parameters.AddValue( "stress_vector_variable", self.settings["compute_error_extra_parameters"] ["stress_vector_variable"]) error_compute_parameters.AddValue("echo_level", self.settings["echo_level"]) if self.dim == 2: self.error_compute = StructuralMechanicsApplication.SPRErrorProcess2D( self.model_part, error_compute_parameters) else: self.error_compute = StructuralMechanicsApplication.SPRErrorProcess3D( self.model_part, error_compute_parameters) # Now we compute the metric error_metric_parameters = KratosMultiphysics.Parameters("""{}""") error_metric_parameters.AddValue("minimal_size", self.settings["minimal_size"]) error_metric_parameters.AddValue("maximal_size", self.settings["maximal_size"]) error_metric_parameters.AddValue( "target_error", self.settings["error_strategy_parameters"] ["error_metric_parameters"]["interpolation_error"]) error_metric_parameters.AddValue( "set_target_number_of_elements", self.settings["error_strategy_parameters"] ["set_target_number_of_elements"]) error_metric_parameters.AddValue( "target_number_of_elements", self.settings["error_strategy_parameters"] ["target_number_of_elements"]) error_metric_parameters.AddValue( "perform_nodal_h_averaging", self.settings["error_strategy_parameters"] ["perform_nodal_h_averaging"]) error_metric_parameters.AddValue("echo_level", self.settings["echo_level"]) if self.dim == 2: self.metric_process = MeshingApplication.MetricErrorProcess2D( self.model_part, error_metric_parameters) else: self.metric_process = MeshingApplication.MetricErrorProcess3D( self.model_part, error_metric_parameters)