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() if (echo_level >= 1): print( "::[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 == True): if (convergence_criterion_parameters["convergence_criterion"]. GetString() == "Displacement_criterion"): self.mechanical_convergence_criterion = StructuralMechanicsApplication.DisplacementAndOtherDoFCriteria( D_RT, D_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_criterion_parameters["convergence_criterion"]. GetString() == "Residual_criterion"): self.mechanical_convergence_criterion = StructuralMechanicsApplication.ResidualDisplacementAndOtherDoFCriteria( R_RT, R_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_criterion_parameters["convergence_criterion"]. GetString() == "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_criterion_parameters["convergence_criterion"]. GetString() == "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) # Convergence criteria without rotation DOFs else: if (convergence_criterion_parameters["convergence_criterion"]. GetString() == "Displacement_criterion"): self.mechanical_convergence_criterion = KratosMultiphysics.DisplacementCriteria( D_RT, D_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_criterion_parameters["convergence_criterion"]. GetString() == "Residual_criterion"): self.mechanical_convergence_criterion = KratosMultiphysics.ResidualCriteria( R_RT, R_AT) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif (convergence_criterion_parameters["convergence_criterion"]. GetString() == "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_criterion_parameters["convergence_criterion"]. GetString() == "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)
def create_constitutive_Law(): return StructuralMechanicsApplication.LinearElasticPlaneStress2DLaw()
def create_constitutive_Law(): return StructuralMechanicsApplication.LinearJ2PlasticityPlaneStrain2DLaw( )
def _add_constitutive_law(self,mp,elastic_flag): cl = StructuralMechanicsApplication.TrussPlasticityConstitutiveLaw() if elastic_flag: cl = StructuralMechanicsApplication.TrussConstitutiveLaw() mp.GetProperties()[0].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW,cl)
def create_constitutive_Law(): return StructuralMechanicsApplication.KirchhoffSaintVenant3DLaw()
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: self.metric_processes.append(MeshingApplication.ComputeHessianSolMetricProcess( 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 )
def test_Uniaxial_HyperElastic_3D(self): nnodes = 4 dim = 3 # Define a model part and create new nodes model_part = KratosMultiphysics.ModelPart("test") node1 = model_part.CreateNewNode(1, 0.0, 0.0, 0.0) node2 = model_part.CreateNewNode(2, 1.0, 0.0, 0.0) node3 = model_part.CreateNewNode(3, 0.0, 1.0, 0.0) node4 = model_part.CreateNewNode(4, 0.0, 0.0, 1.0) # Material properties prop_id = 0 properties = model_part.Properties[prop_id] young_modulus = 200e9 poisson_ratio = 0.3 properties.SetValue(KratosMultiphysics.YOUNG_MODULUS, young_modulus) properties.SetValue(KratosMultiphysics.POISSON_RATIO, poisson_ratio) # Allocate a geometry geom = KratosMultiphysics.Tetrahedra3D4(node1,node2,node3, node4) N = KratosMultiphysics.Vector(4) DN_DX = KratosMultiphysics.Matrix(4,3) # Construct a constitutive law cl = StructuralMechanicsApplication.HyperElastic3DLaw() cl.Check(properties, geom, model_part.ProcessInfo) if(cl.WorkingSpaceDimension() != dim): raise Exception("Mismatch between the WorkingSpaceDimension of the Constitutive Law and the dimension of the space in which the test is performed") ## Set the parameters to be employed #note that here i am adding them all to check that this does not fail cl_options = KratosMultiphysics.Flags() cl_options.Set(KratosMultiphysics.ConstitutiveLaw.USE_ELEMENT_PROVIDED_STRAIN, False) cl_options.Set(KratosMultiphysics.ConstitutiveLaw.COMPUTE_STRESS, True) cl_options.Set(KratosMultiphysics.ConstitutiveLaw.COMPUTE_CONSTITUTIVE_TENSOR, True) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.COMPUTE_STRAIN_ENERGY, False) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.ISOCHORIC_TENSOR_ONLY, False) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.VOLUMETRIC_TENSOR_ONLY, False) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.FINALIZE_MATERIAL_RESPONSE, False) # From here below it should be an otput not an input cl_options.Set(KratosMultiphysics.ConstitutiveLaw.FINITE_STRAINS, True) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.INFINITESIMAL_STRAINS, False) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.PLANE_STRAIN_LAW, False) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.PLANE_STRESS_LAW, False) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.AXISYMMETRIC_LAW, False) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.U_P_LAW, False) cl_options.Set(KratosMultiphysics.ConstitutiveLaw.ISOTROPIC, True) #cl_options.Set(KratosMultiphysics.ConstitutiveLaw.ANISOTROPIC, False) F = KratosMultiphysics.Matrix(3,3) F[0,0] = 1.0; F[0,1] = 0.0; F[0,2] = 0.0; F[1,0] = 0.0; F[1,1] = 1.0; F[1,2] = 0.0; F[2,0] = 0.0; F[2,1] = 0.0; F[2,2] = 1.0; detF = 1.0 stress_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) strain_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) constitutive_matrix = KratosMultiphysics.Matrix(cl.GetStrainSize(),cl.GetStrainSize()) # Setting the parameters - note that a constitutive law may not need them all! cl_params = KratosMultiphysics.ConstitutiveLawParameters() cl_params.SetOptions(cl_options) cl_params.SetDeformationGradientF(F) cl_params.SetDeterminantF(detF) cl_params.SetStrainVector(strain_vector) cl_params.SetStressVector(stress_vector) cl_params.SetConstitutiveMatrix(constitutive_matrix) cl_params.SetShapeFunctionsValues(N) cl_params.SetShapeFunctionsDerivatives(DN_DX) cl_params.SetProcessInfo(model_part.ProcessInfo) cl_params.SetMaterialProperties(properties) cl_params.SetElementGeometry(geom) ## Do all sort of checks cl_params.CheckAllParameters() # Can not use this until the geometry is correctly exported to python cl_params.CheckMechanicalVariables() cl_params.CheckShapeFunctions() #print("The Material Response PK2") #cl.CalculateMaterialResponsePK2(cl_params) #print("Stress = ", cl_params.GetStressVector()) #print("Strain = ", cl_params.GetStrainVector()) #print("C = ", cl_params.GetConstitutiveMatrix()) #cl.FinalizeMaterialResponsePK2(cl_params) #cl.FinalizeSolutionStep(properties, geom, N, model_part.ProcessInfo) #print("\n The Material Response Kirchhoff") #cl.CalculateMaterialResponseKirchhoff(cl_params) #print("Stress = ", cl_params.GetStressVector()) #print("Strain = ", cl_params.GetStrainVector()) #print("C = ", cl_params.GetConstitutiveMatrix()) #cl.FinalizeMaterialResponseKirchhoff(cl_params) #cl.FinalizeSolutionStep(properties, geom, N, model_part.ProcessInfo) #print("\n The Material Response Cauchy") #cl.CalculateMaterialResponseCauchy(cl_params) #print("Stress = ", cl_params.GetStressVector()) #print("Strain = ", cl_params.GetStrainVector()) #print("C = ", cl_params.GetConstitutiveMatrix()) #cl.FinalizeMaterialResponseCauchy(cl_params) #cl.FinalizeSolutionStep(properties, geom, N, model_part.ProcessInfo) # Check the results lame_lambda = (young_modulus * poisson_ratio) / ((1.0 + poisson_ratio) * (1.0 - 2.0 * poisson_ratio)) lame_mu = young_modulus / (2.0 * (1.0 + poisson_ratio)) reference_stress = KratosMultiphysics.Vector(cl.GetStrainSize()) for i in range(cl.GetStrainSize()): reference_stress[i] = 0.0 for i in range(100): F[0,0] = 1.0 + 0.2 * i detF = 1.0 + 0.2 * i cl_params.SetDeformationGradientF(F) cl_params.SetDeterminantF(detF) cl.CalculateMaterialResponseCauchy(cl_params) cl.FinalizeMaterialResponseCauchy(cl_params) cl.FinalizeSolutionStep(properties, geom, N, model_part.ProcessInfo) reference_stress[0] = (lame_lambda * math.log(detF) + lame_mu * (detF ** 2.0 - 1.0)) / detF reference_stress[1] = (lame_lambda * math.log(detF)) / detF reference_stress[2] = reference_stress[1] stress = cl_params.GetStressVector() for j in range(cl.GetStrainSize()): self.assertAlmostEqual(reference_stress[j], stress[j], 2)
def test_SmallDisplacementElement_3D_hexa(self): dim = 3 current_model = KratosMultiphysics.Model() mp = current_model.CreateModelPart("solid_part") self._add_variables(mp) self._apply_material_properties(mp, dim) #create nodes mp.CreateNewNode(1, 0.00000, 1.00000, 1.00000) mp.CreateNewNode(2, 0.16500, 0.74500, 0.70200) mp.CreateNewNode(3, 0.27300, 0.75000, 0.23000) mp.CreateNewNode(4, 0.78800, 0.69300, 0.64400) mp.CreateNewNode(5, 0.32000, 0.18600, 0.64300) mp.CreateNewNode(6, 0.00000, 1.00000, 0.00000) mp.CreateNewNode(7, 0.00000, 0.00000, 1.00000) mp.CreateNewNode(8, 1.00000, 1.00000, 1.00000) mp.CreateNewNode(9, 0.67700, 0.30500, 0.68300) mp.CreateNewNode(10, 0.24900, 0.34200, 0.19200) mp.CreateNewNode(11, 0.85000, 0.64900, 0.26300) mp.CreateNewNode(12, 0.82600, 0.28800, 0.28800) mp.CreateNewNode(13, 0.00000, 0.00000, 0.00000) mp.CreateNewNode(14, 1.00000, 1.00000, 0.00000) mp.CreateNewNode(15, 1.00000, 0.00000, 1.00000) mp.CreateNewNode(16, 1.00000, 0.00000, 0.00000) 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) #create a submodelpart for boundary conditions bcs = mp.CreateSubModelPart("BoundaryCondtions") bcs.AddNodes([1, 6, 7, 8, 13, 14, 15, 16]) #create Element mp.CreateNewElement("SmallDisplacementElement3D8N", 1, [10, 5, 2, 3, 13, 7, 1, 6], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D8N", 2, [12, 9, 5, 10, 16, 15, 7, 13], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D8N", 3, [12, 11, 3, 10, 9, 4, 2, 5], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D8N", 4, [9, 4, 2, 5, 15, 8, 1, 7], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D8N", 5, [4, 11, 3, 2, 8, 14, 6, 1], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D8N", 6, [11, 4, 9, 12, 14, 8, 15, 16], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D8N", 7, [11, 12, 10, 3, 14, 16, 13, 6], mp.GetProperties()[1]) A, b = self._define_movement(dim) self._apply_BCs(bcs, A, b) self._solve(mp) self._check_results(mp, A, b) self._check_outputs(mp, A, dim) #self.__post_process(mp) # Testing explicit utilities empty_param = KratosMultiphysics.Parameters("""{}""") max_delta_time = StructuralMechanicsApplication.CalculateDeltaTime( mp, empty_param) self.assertAlmostEqual(max_delta_time, 4.764516014904737e-07)
def test_SmallDisplacementElement_3D_tetra_user_provided_elasticity(self): dim = 3 current_model = KratosMultiphysics.Model() mp = current_model.CreateModelPart("solid_part") self._add_variables(mp) #set the user-provided elasticity tensor E = 200e+9 nu = 0.3 c1 = E / ((1.00+nu) * (1-2*nu)) c2 = c1 * (1-nu) c3 = c1 * nu c4 = c1 * 0.5 * (1-2*nu) elasticity_tensor = KratosMultiphysics.Matrix(6,6) for i in range(6): for j in range(6): elasticity_tensor[i,j] = 0.0 elasticity_tensor[0, 0] = c2 elasticity_tensor[0, 1] = c3 elasticity_tensor[0, 2] = c3 elasticity_tensor[1, 0] = c3 elasticity_tensor[1, 1] = c2 elasticity_tensor[1, 2] = c3 elasticity_tensor[2, 0] = c3 elasticity_tensor[2, 1] = c3 elasticity_tensor[2, 2] = c2 elasticity_tensor[3, 3] = c4 elasticity_tensor[4, 4] = c4 elasticity_tensor[5, 5] = c4 #apply isotropic user-provided material properties claw = StructuralMechanicsApplication.UserProvidedLinearElastic3DLaw() mp.GetProperties()[1].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW, claw) mp.GetProperties()[1].SetValue(StructuralMechanicsApplication.ELASTICITY_TENSOR, elasticity_tensor) #create nodes mp.CreateNewNode(1,0.0, 1.0, 0.0) mp.CreateNewNode(2,0.0, 1.0, 0.1) mp.CreateNewNode(3, 0.28739360416666665, 0.27808503701741405, 0.05672979583333333) mp.CreateNewNode(4, 0.0, 0.1, 0.0) mp.CreateNewNode(5, 0.1, 0.1, 0.1) mp.CreateNewNode(6, 1.0, 0.0, 0.0) mp.CreateNewNode(7, 1.2, 0.0, 0.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) #create a submodelpart for boundary conditions bcs = mp.CreateSubModelPart("BoundaryCondtions") bcs.AddNodes([1,2,4,5,6,7]) #create Element mp.CreateNewElement("SmallDisplacementElement3D4N", 1,[5,3,1,2], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D4N", 2,[3,1,2,6], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D4N", 3,[6,4,7,3], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D4N", 4,[5,4,1,3], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D4N", 5,[4,1,3,6], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D4N", 6,[5,4,3,7], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D4N", 7,[3,5,7,2], mp.GetProperties()[1]) mp.CreateNewElement("SmallDisplacementElement3D4N", 8,[6,7,2,3], mp.GetProperties()[1]) A,b = self._define_movement(dim) self._apply_BCs(bcs,A,b) self._solve(mp) self._check_results(mp,A,b) self._check_outputs(mp,A,dim)
def create_constitutive_Law(): return StructuralMechanicsApplication.SmallStrainIsotropicDamagePlaneStrain2DLaw( )
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 uses LinearMasterSlaveConstraint in order to impose an unified movement in the given submodelpart. The process takes the first node from the submodelpart if no node's ID is provided. The default variable is DISPLACEMENT, and in case no variable is considered for the slave the same variable will be considered", "main_model_part_name" : "Structure", "model_part_name" : "please_specify_model_part_name", "new_model_part_name" : "", "interval" : [0.0, 1e30], "master_variable_name" : "DISPLACEMENT", "slave_variable_name" : "", "relation" : 1.0, "constant" : 0.0, "master_node_id" : 0 } """) # 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) # The main model part self.main_model_part = Model[ settings["main_model_part_name"].GetString()] # Assign this here since it will change the "interval" prior to validation self.interval = KratosMultiphysics.IntervalUtility(settings) # We get the corresponding model parts self.model_part = self.main_model_part.GetSubModelPart( settings["model_part_name"].GetString()) new_model_part_name = settings["new_model_part_name"].GetString() if new_model_part_name != "": if self.model_part.HasSubModelPart(new_model_part_name): self.rigid_model_part = self.model_part.GetSubModelPart( new_model_part_name) else: self.rigid_model_part = self.model_part.CreateSubModelPart( new_model_part_name) else: settings["new_model_part_name"].SetString( settings["model_part_name"].GetString()) self.rigid_model_part = self.model_part # Create the process rigid_parameters = KratosMultiphysics.Parameters("""{}""") rigid_parameters.AddValue("model_part_name", settings["model_part_name"]) rigid_parameters.AddValue("new_model_part_name", settings["new_model_part_name"]) rigid_parameters.AddValue("master_variable_name", settings["master_variable_name"]) rigid_parameters.AddValue("slave_variable_name", settings["slave_variable_name"]) rigid_parameters.AddValue("relation", settings["relation"]) rigid_parameters.AddValue("constant", settings["constant"]) rigid_parameters.AddValue("master_node_id", settings["master_node_id"]) self.rigid_movement_process = StructuralMechanicsApplication.ImposeRigidMovementProcess( self.main_model_part, rigid_parameters) # Trasfering the entities if new_model_part_name != "": transfer_process = KratosMultiphysics.FastTransferBetweenModelPartsProcess( self.rigid_model_part, self.model_part, KratosMultiphysics. FastTransferBetweenModelPartsProcess.EntityTransfered.NODES) transfer_process.Execute()
def test_Shear_Plus_Strech_HyperElastic_3D(self): nnodes = 4 dim = 3 # Define a model and geometry model_part = KratosMultiphysics.ModelPart("test") geom = self._create_geometry(model_part, dim, nnodes) # Material properties young_modulus = 200e9 poisson_ratio = 0.3 properties = self._create_properties(model_part, young_modulus, poisson_ratio) N = KratosMultiphysics.Vector(nnodes) DN_DX = KratosMultiphysics.Matrix(nnodes, dim) # Construct a constitutive law cl = StructuralMechanicsApplication.HyperElastic3DLaw() self._cl_check(cl, properties, geom, model_part, dim) # Set the parameters to be employed dict_options = { 'USE_ELEMENT_PROVIDED_STRAIN': False, 'COMPUTE_STRESS': True, 'COMPUTE_CONSTITUTIVE_TENSOR': True, 'FINITE_STRAINS': True, 'ISOTROPIC': True, } cl_options = self._set_cl_options(dict_options) # Define deformation gradient F = self._create_F() detF = 1.0 stress_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) strain_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) constitutive_matrix = KratosMultiphysics.Matrix( cl.GetStrainSize(), cl.GetStrainSize()) # Setting the parameters - note that a constitutive law may not need them all! cl_params = self._set_cl_parameters(cl_options, F, detF, strain_vector, stress_vector, constitutive_matrix, N, DN_DX, model_part, properties, geom) # Check the results lame_lambda = (young_modulus * poisson_ratio) / ( (1.0 + poisson_ratio) * (1.0 - 2.0 * poisson_ratio)) lame_mu = young_modulus / (2.0 * (1.0 + poisson_ratio)) reference_stress = KratosMultiphysics.Vector(cl.GetStrainSize()) for i in range(cl.GetStrainSize()): reference_stress[i] = 0.0 x1beta = 1.0 x2beta = 1.0 x3beta = math.pi / 200 for i in range(100): F[0, 0] = math.cos(x3beta * i) F[0, 1] = -math.sin(x3beta * i) F[1, 0] = math.sin(x3beta * i) F[1, 1] = math.cos(x3beta * i) F[0, 2] = -x1beta * math.sin(x3beta * i) - x2beta * math.cos( x3beta * i) F[1, 2] = x1beta * math.cos(x3beta * i) - x2beta * math.sin( x3beta * i) cl_params.SetDeformationGradientF(F) cl.CalculateMaterialResponseCauchy(cl_params) cl.FinalizeMaterialResponseCauchy(cl_params) cl.FinalizeSolutionStep(properties, geom, N, model_part.ProcessInfo) reference_stress[0] = (x2beta * math.cos(i * x3beta) + x1beta * math.sin(i * x3beta))**2.0 reference_stress[1] = (x1beta * math.cos(i * x3beta) - x2beta * math.sin(i * x3beta))**2.0 reference_stress[3] = (x2beta * math.cos(i * x3beta) + x1beta * math.sin(i * x3beta)) * ( -x1beta * math.cos(i * x3beta) + x2beta * math.sin(i * x3beta)) reference_stress[4] = x1beta * math.cos( i * x3beta) - x2beta * math.sin(i * x3beta) reference_stress[5] = -x2beta * math.cos( i * x3beta) - x1beta * math.sin(i * x3beta) reference_stress *= lame_mu stress = cl_params.GetStressVector() for j in range(cl.GetStrainSize()): self.assertAlmostEqual(reference_stress[j], stress[j], 2)
def test_Uniaxial_KirchhoffSaintVenant_3D(self): nnodes = 4 dim = 3 # Define a model and geometry model_part = KratosMultiphysics.ModelPart("test") geom = self._create_geometry(model_part, dim, nnodes) # Material properties young_modulus = 200e9 poisson_ratio = 0.3 properties = self._create_properties(model_part, young_modulus, poisson_ratio) N = KratosMultiphysics.Vector(nnodes) DN_DX = KratosMultiphysics.Matrix(nnodes, dim) # Construct a constitutive law cl = StructuralMechanicsApplication.KirchhoffSaintVenant3DLaw() self._cl_check(cl, properties, geom, model_part, dim) # Set the parameters to be employed dict_options = { 'USE_ELEMENT_PROVIDED_STRAIN': False, 'COMPUTE_STRESS': True, 'COMPUTE_CONSTITUTIVE_TENSOR': True, 'FINITE_STRAINS': True, 'ISOTROPIC': True, } cl_options = self._set_cl_options(dict_options) # Define deformation gradient F = self._create_F() detF = 1.0 stress_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) strain_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) constitutive_matrix = KratosMultiphysics.Matrix( cl.GetStrainSize(), cl.GetStrainSize()) # Setting the parameters - note that a constitutive law may not need them all! cl_params = self._set_cl_parameters(cl_options, F, detF, strain_vector, stress_vector, constitutive_matrix, N, DN_DX, model_part, properties, geom) # Check the results lame_lambda = (young_modulus * poisson_ratio) / ( (1.0 + poisson_ratio) * (1.0 - 2.0 * poisson_ratio)) lame_mu = young_modulus / (2.0 * (1.0 + poisson_ratio)) reference_stress = KratosMultiphysics.Vector(cl.GetStrainSize()) for i in range(cl.GetStrainSize()): reference_stress[i] = 0.0 for i in range(100): F[0, 0] = 1.0 + 0.05 * i detF = 1.0 + 0.05 * i cl_params.SetDeformationGradientF(F) cl_params.SetDeterminantF(detF) # Chauchy cl.CalculateMaterialResponseCauchy(cl_params) cl.FinalizeMaterialResponseCauchy(cl_params) cl.FinalizeSolutionStep(properties, geom, N, model_part.ProcessInfo) reference_stress[0] = ((lame_lambda * 0.5 + lame_mu) * (detF**2.0 - 1.0) * (detF**2.0)) / detF reference_stress[1] = 0.5 * lame_lambda * (detF**2.0 - 1.0) / detF reference_stress[2] = reference_stress[1] stress = cl_params.GetStressVector() for j in range(cl.GetStrainSize()): self.assertAlmostEqual(reference_stress[j], stress[j], 2)
def test_J2_Plasticity_3D(self): nnodes = 8 dim = 3 # Define a model and geometry model_part = KratosMultiphysics.ModelPart("test") geom = self._create_geometry(model_part, dim, nnodes) # Material properties prop_id = 0 properties = model_part.Properties[prop_id] properties.SetValue(KratosMultiphysics.YOUNG_MODULUS, 21000) properties.SetValue(KratosMultiphysics.POISSON_RATIO, 0.3) properties.SetValue(KratosMultiphysics.YIELD_STRESS, 5.5) properties.SetValue(KratosMultiphysics.REFERENCE_HARDENING_MODULUS, 1.0) properties.SetValue(KratosMultiphysics.ISOTROPIC_HARDENING_MODULUS, 0.12924) properties.SetValue(KratosMultiphysics.INFINITY_HARDENING_MODULUS, 0.0) properties.SetValue(KratosMultiphysics.HARDENING_EXPONENT, 1.0) N = KratosMultiphysics.Vector(nnodes) DN_DX = KratosMultiphysics.Matrix(nnodes, dim) # Construct a constitutive law cl = StructuralMechanicsApplication.LinearJ2Plasticity3DLaw() self._cl_check(cl, properties, geom, model_part, dim) # Set the parameters to be employed dict_options = { 'USE_ELEMENT_PROVIDED_STRAIN': False, 'COMPUTE_STRESS': True, 'COMPUTE_CONSTITUTIVE_TENSOR': True, } cl_options = self._set_cl_options(dict_options) stress_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) strain_vector = KratosMultiphysics.Vector(cl.GetStrainSize()) constitutive_matrix = KratosMultiphysics.Matrix( cl.GetStrainSize(), cl.GetStrainSize()) # Setting the parameters - note that a constitutive law may not need them all! F = self._create_F() detF = 1.0 cl_params = self._set_cl_parameters(cl_options, F, detF, strain_vector, stress_vector, constitutive_matrix, N, DN_DX, model_part, properties, geom) cl.InitializeMaterial(properties, geom, N) # Check the results nr_timesteps = 10 rstress = [] for i in range(nr_timesteps): rstress.append(KratosMultiphysics.Vector(cl.GetStrainSize())) rstress[0][0] = 4.03846 rstress[0][1] = 4.03846 rstress[0][2] = 2.42308 rstress[0][3] = 0.80769 rstress[0][4] = 0.0 rstress[0][5] = 0.80769 rstress[1][0] = 8.07692 rstress[1][1] = 8.07692 rstress[1][2] = 4.84615 rstress[1][3] = 1.61538 rstress[1][4] = 0.0 rstress[1][5] = 1.61538 rstress[2][0] = 11.6595 rstress[2][1] = 11.6595 rstress[2][2] = 8.18099 rstress[2][3] = 1.73926 rstress[2][4] = 0.0 rstress[2][5] = 1.73926 rstress[3][0] = 15.1595 rstress[3][1] = 15.1595 rstress[3][2] = 11.681 rstress[3][3] = 1.73926 rstress[3][4] = 0.0 rstress[3][5] = 1.73926 rstress[4][0] = 18.6595 rstress[4][1] = 18.6595 rstress[4][2] = 15.181 rstress[4][3] = 1.73926 rstress[4][4] = 0.0 rstress[4][5] = 1.73926 rstress[5][0] = 22.1595 rstress[5][1] = 22.1595 rstress[5][2] = 18.681 rstress[5][3] = 1.73927 rstress[5][4] = 0.0 rstress[5][5] = 1.73927 rstress[6][0] = 25.6595 rstress[6][1] = 25.6595 rstress[6][2] = 22.181 rstress[6][3] = 1.73927 rstress[6][4] = 0.0 rstress[6][5] = 1.73927 rstress[7][0] = 29.1595 rstress[7][1] = 29.1595 rstress[7][2] = 25.681 rstress[7][3] = 1.73928 rstress[7][4] = 0.0 rstress[7][5] = 1.73928 rstress[8][0] = 32.6595 rstress[8][1] = 32.6595 rstress[8][2] = 29.181 rstress[8][3] = 1.73928 rstress[8][4] = 0.0 rstress[8][5] = 1.73928 rstress[9][0] = 36.1595 rstress[9][1] = 36.1595 rstress[9][2] = 32.681 rstress[9][3] = 1.73929 rstress[9][4] = 0.0 rstress[9][5] = 1.73929 initial_strain = KratosMultiphysics.Vector(cl.GetStrainSize()) initial_strain[0] = 0.001 initial_strain[1] = 0.001 initial_strain[2] = 0.0 initial_strain[3] = 0.001 initial_strain[4] = 0.0 initial_strain[5] = 0.001 t = dt = 1. / nr_timesteps c = 0 while (t <= 1. + dt / 10.): strain = t * initial_strain cl_params.SetStrainVector(strain) # Chauchy cl.CalculateMaterialResponseCauchy(cl_params) cl.FinalizeMaterialResponseCauchy(cl_params) cl.FinalizeSolutionStep(properties, geom, N, model_part.ProcessInfo) stress = cl_params.GetStressVector() for j in range(cl.GetStrainSize()): self.assertAlmostEqual(rstress[c][j], stress[j], 4) t += dt c += 1
def _apply_material_properties(self, mp): cl = StructuralMechanicsApplication.LinearElasticPlaneStress2DLaw() mp.GetProperties()[1].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW, cl)
def test_membrane_wrinkling_law(self): self.skipTestIfApplicationsNotAvailable("ConstitutiveLawsApplication") current_model = KratosMultiphysics.Model() mp = current_model.CreateModelPart("Structure") mp.SetBufferSize(2) mp.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] = 3 self._add_variables(mp) # add properties and subproperties mp.GetProperties()[1].SetValue(KratosMultiphysics.YOUNG_MODULUS, 206900000000.0) mp.GetProperties()[1].SetValue(KratosMultiphysics.POISSON_RATIO, 0.30) mp.GetProperties()[1].SetValue(KratosMultiphysics.THICKNESS, 0.0001) mp.GetProperties()[1].SetValue(KratosMultiphysics.DENSITY, 7850.0) constitutive_law = ConstitutiveLawsApplication.WrinklingLinear2DLaw() mp.GetProperties()[1].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW, constitutive_law) sub_constitutive_law = StructuralMechanicsApplication.LinearElasticPlaneStress2DLaw( ) mp.GetProperties()[2].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW, sub_constitutive_law) mp.GetProperties()[1].AddSubProperties(mp.GetProperties()[2]) mp.GetProperties()[1].SetValue( KratosMultiphysics.COMPUTE_LUMPED_MASS_MATRIX, True) # create nodes mp.CreateNewNode(1, 0.0000000000, 1.0000000000, 0.0000000000) mp.CreateNewNode(2, 0.0000000000, 0.0000000000, 0.0000000000) mp.CreateNewNode(3, 1.0000000000, 1.0000000000, 0.0000000000) mp.CreateNewNode(4, 1.0000000000, 0.0000000000, 0.0000000000) # add dofs self._add_dofs(mp) # create element element_name = "MembraneElement3D4N" mp.CreateNewElement(element_name, 1, [4, 3, 1, 2], mp.GetProperties()[1]) # create & apply dirichlet bcs bcs_dirichlet_all = mp.CreateSubModelPart( "BoundaryCondtionsDirichletAll") bcs_dirichlet_all.AddNodes([2, 4]) bcs_dirichlet_mv = mp.CreateSubModelPart( "BoundaryCondtionsDirichletMove") bcs_dirichlet_mv.AddNodes([1, 3]) self._apply_dirichlet_BCs(bcs_dirichlet_all) self._apply_dirichlet_BCs(bcs_dirichlet_mv, fix_type='YZ') # create & apply neumann bcs mp.CreateNewCondition("PointLoadCondition3D1N", 1, [1], mp.GetProperties()[1]) mp.CreateNewCondition("PointLoadCondition3D1N", 2, [3], mp.GetProperties()[1]) bcs_neumann = mp.CreateSubModelPart("BoundaryCondtionsNeumann") bcs_neumann.AddNodes([1, 3]) bcs_neumann.AddConditions([1, 2]) KratosMultiphysics.VariableUtils().SetScalarVar( StructuralMechanicsApplication.POINT_LOAD_X, 1000000.0, bcs_neumann.Nodes) # solve self._solve_static(mp) # check results self.assertAlmostEqual( mp.Nodes[1].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_X), 0.58054148514004470, 4) self.assertAlmostEqual( mp.Nodes[3].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_X), 0.15072065295319598, 4)
def create_constitutive_Law(): return StructuralMechanicsApplication.SmallStrainJ2Plasticity3DLaw()
def test_membrane_cauchy_stress_and_local_axis(self): current_model = KratosMultiphysics.Model() mp = current_model.CreateModelPart("Structure") mp.SetBufferSize(2) mp.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] = 3 self._add_variables(mp) # add properties and subproperties thickness = 1.3 height = 1.2 length = 10.0 mp.GetProperties()[1].SetValue(KratosMultiphysics.YOUNG_MODULUS, 500.0) mp.GetProperties()[1].SetValue(KratosMultiphysics.POISSON_RATIO, 0.00) mp.GetProperties()[1].SetValue(KratosMultiphysics.THICKNESS, thickness) mp.GetProperties()[1].SetValue(KratosMultiphysics.DENSITY, 7850.0) mp.GetProperties()[1].SetValue( KratosMultiphysics.CONSTITUTIVE_LAW, StructuralMechanicsApplication.LinearElasticPlaneStress2DLaw()) # create nodes mp.CreateNewNode(1, -0.668004, 0.9192533, 0.3856725) mp.CreateNewNode(2, 0.0, 0.0, 0.0) mp.CreateNewNode(3, 5.966131, 7.3471293, -3.4445475) mp.CreateNewNode(4, 6.634135, 6.427876, -3.83022) # add dofs self._add_dofs(mp) # create element element_name = "MembraneElement3D4N" mp.CreateNewElement(element_name, 1, [4, 3, 1, 2], mp.GetProperties()[1]) # create & apply dirichlet bcs bcs_dirichlet_all = mp.CreateSubModelPart( "BoundaryCondtionsDirichletAll") bcs_dirichlet_all.AddNodes([1, 2]) self._apply_dirichlet_BCs(bcs_dirichlet_all) # create & apply neumann bcs mp.CreateNewCondition("PointLoadCondition3D1N", 1, [3], mp.GetProperties()[1]) mp.CreateNewCondition("PointLoadCondition3D1N", 2, [4], mp.GetProperties()[1]) bcs_neumann = mp.CreateSubModelPart("BoundaryCondtionsNeumann") bcs_neumann.AddNodes([3, 4]) bcs_neumann.AddConditions([1, 2]) point_load = 5.0 KratosMultiphysics.VariableUtils().SetScalarVar( StructuralMechanicsApplication.POINT_LOAD_X, point_load * 0.6634135, bcs_neumann.Nodes) KratosMultiphysics.VariableUtils().SetScalarVar( StructuralMechanicsApplication.POINT_LOAD_Y, point_load * 0.6427876, bcs_neumann.Nodes) KratosMultiphysics.VariableUtils().SetScalarVar( StructuralMechanicsApplication.POINT_LOAD_Z, point_load * (-0.383022), bcs_neumann.Nodes) ## 1.) with local axis calculated from element (dependent on node numbering) cauchy_stress_analytical = point_load * len( bcs_neumann.Nodes) / (thickness * height) # solve self._solve_static(mp) disp_x_i = mp.Nodes[4].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_X) disp_y_i = mp.Nodes[4].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_Y) disp_z_i = mp.Nodes[4].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_Z) disp_i = (disp_x_i**2 + disp_y_i**2 + disp_z_i**2)**0.5 det_F_inv = length / (length + disp_i) for element_i in mp.Elements: pk2 = element_i.CalculateOnIntegrationPoints( KratosMultiphysics.PK2_STRESS_VECTOR, mp.ProcessInfo) cauchy = element_i.CalculateOnIntegrationPoints( KratosMultiphysics.CAUCHY_STRESS_VECTOR, mp.ProcessInfo) # check results for i in range(4): self.assertAlmostEqual(cauchy[i][0], 0.0, 5) self.assertAlmostEqual(cauchy[i][1], cauchy_stress_analytical, 5) self.assertAlmostEqual(cauchy[i][2], 0.0, 5) self.assertAlmostEqual(pk2[i][0], 0.0, 5) self.assertAlmostEqual(pk2[i][1], cauchy_stress_analytical * det_F_inv, 5) self.assertAlmostEqual(pk2[i][2], 0.0, 5) ## 2.) with local mat_axis = 0.6634135,0.6427876,-0.383022 : along forces projection_settings = KratosMultiphysics.Parameters(""" { "model_part_name" : "Structure", "projection_type" : "planar", "global_direction" : [0.6634135,0.6427876,-0.383022], "variable_name" : "LOCAL_MATERIAL_AXIS_1" } """) StructuralMechanicsApplication.ProjectVectorOnSurfaceUtility.Execute( mp, projection_settings) # solve self._solve_static(mp) disp_x_i = mp.Nodes[4].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_X) disp_y_i = mp.Nodes[4].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_Y) disp_z_i = mp.Nodes[4].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_Z) disp_i = (disp_x_i**2 + disp_y_i**2 + disp_z_i**2)**0.5 det_F_inv = length / (length + disp_i) for element_i in mp.Elements: pk2 = element_i.CalculateOnIntegrationPoints( KratosMultiphysics.PK2_STRESS_VECTOR, mp.ProcessInfo) cauchy = element_i.CalculateOnIntegrationPoints( KratosMultiphysics.CAUCHY_STRESS_VECTOR, mp.ProcessInfo) # check results for i in range(4): self.assertAlmostEqual(cauchy[i][0], cauchy_stress_analytical, 5) self.assertAlmostEqual(cauchy[i][1], 0.0, 5) self.assertAlmostEqual(cauchy[i][2], 0.0, 5) self.assertAlmostEqual(pk2[i][0], cauchy_stress_analytical * det_F_inv, 5) self.assertAlmostEqual(pk2[i][1], 0.0, 5) self.assertAlmostEqual(pk2[i][2], 0.0, 5) ## 3.) with local mat_axis = 0.07537005, 0.9961943, -0.0437662 -> rotate stress state by 45° cauchy_stress_analytical /= 2.0 projection_settings = KratosMultiphysics.Parameters(""" { "model_part_name" : "Structure", "projection_type" : "planar", "global_direction" : [0.07537005, 0.9961943, -0.0437662], "variable_name" : "LOCAL_MATERIAL_AXIS_1" } """) StructuralMechanicsApplication.ProjectVectorOnSurfaceUtility.Execute( mp, projection_settings) # solve self._solve_static(mp) disp_x_i = mp.Nodes[4].GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_X) det_F_inv = length / (length + disp_x_i) for element_i in mp.Elements: cauchy = element_i.CalculateOnIntegrationPoints( KratosMultiphysics.CAUCHY_STRESS_VECTOR, mp.ProcessInfo) # check results for i in range(4): self.assertAlmostEqual(cauchy[i][0], cauchy_stress_analytical, 5) self.assertAlmostEqual(cauchy[i][1], cauchy_stress_analytical, 5) self.assertAlmostEqual(abs(cauchy[i][2]), cauchy_stress_analytical, 5)
def _base_fall_test_dynamic_schemes(self, current_model, scheme_name="bossak", buffer_size=2, dt=1.0e-2): mp = current_model.CreateModelPart("sdof") mp.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] = 2 add_variables(mp, scheme_name) if (scheme_name == "explicit"): # Create node node = mp.CreateNewNode(1, 0.0, 0.0, 0.0) node.AddDof(KratosMultiphysics.DISPLACEMENT_X) node.AddDof(KratosMultiphysics.DISPLACEMENT_Y) node.AddDof(KratosMultiphysics.DISPLACEMENT_Z) second_node = mp.CreateNewNode(2, 1.0, 0.0, 0.0) second_node.AddDof(KratosMultiphysics.DISPLACEMENT_X) second_node.AddDof(KratosMultiphysics.DISPLACEMENT_Y) second_node.AddDof(KratosMultiphysics.DISPLACEMENT_Z) #add bcs and initial values node.Fix(KratosMultiphysics.DISPLACEMENT_X) node.Fix(KratosMultiphysics.DISPLACEMENT_Z) node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Y, 0, 0.0) second_node.Fix(KratosMultiphysics.DISPLACEMENT_X) second_node.Fix(KratosMultiphysics.DISPLACEMENT_Z) second_node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Y, 0, 0.0) #create element prop = mp.GetProperties()[1] prop.SetValue( KratosMultiphysics.CONSTITUTIVE_LAW, StructuralMechanicsApplication.TrussConstitutiveLaw()) prop.SetValue(KratosMultiphysics.DENSITY, 1.0) prop.SetValue(StructuralMechanicsApplication.CROSS_AREA, 1.0) prop.SetValue(KratosMultiphysics.YOUNG_MODULUS, 1.0) prop.SetValue(StructuralMechanicsApplication.TRUSS_PRESTRESS_PK2, 0.0) element = mp.CreateNewElement("TrussElement3D2N", 1, [1, 2], prop) gravity = -9.81 node.SetSolutionStepValue(KratosMultiphysics.VOLUME_ACCELERATION_Y, 0, gravity) second_node.SetSolutionStepValue( KratosMultiphysics.VOLUME_ACCELERATION_Y, 0, gravity) else: # Create node node = mp.CreateNewNode(1, 0.0, 0.0, 0.0) node.AddDof(KratosMultiphysics.DISPLACEMENT_X) node.AddDof(KratosMultiphysics.DISPLACEMENT_Y) node.AddDof(KratosMultiphysics.DISPLACEMENT_Z) #add bcs and initial values node.Fix(KratosMultiphysics.DISPLACEMENT_X) node.Fix(KratosMultiphysics.DISPLACEMENT_Z) node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Y, 0, 0.0) #create element element = mp.CreateNewElement("NodalConcentratedElement3D1N", 1, [1], mp.GetProperties()[1]) mass = 1.0 stiffness = 0.0 element.SetValue(KratosMultiphysics.NODAL_MASS, mass) element.SetValue(StructuralMechanicsApplication.NODAL_STIFFNESS, [0, stiffness, 0]) gravity = -9.81 node.SetSolutionStepValue(KratosMultiphysics.VOLUME_ACCELERATION_Y, 0, gravity) #time integration parameters time = 0.0 end_time = 1.0e-1 step = 0 set_and_fill_buffer(mp, buffer_size, dt) #parameters for analytical solution self.strategy = create_solver(mp, scheme_name) current_analytical_displacement_y = 0.0 current_analytical_velocity_y = 0.0 current_analytical_acceleration_y = 0.0 # Fill buffer solution for i in range(buffer_size): time = time + dt step = i + 1 mp.CloneTimeStep(time) mp.ProcessInfo[KratosMultiphysics.STEP] = step current_analytical_displacement_y += current_analytical_velocity_y * dt + 0.25 * ( current_analytical_acceleration_y + gravity) * dt**2 current_analytical_velocity_y += dt * 0.5 * ( current_analytical_acceleration_y + gravity) current_analytical_acceleration_y = gravity node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Y, 0, current_analytical_displacement_y) node.SetSolutionStepValue(KratosMultiphysics.VELOCITY_Y, 0, current_analytical_velocity_y) node.SetSolutionStepValue(KratosMultiphysics.ACCELERATION_Y, 0, current_analytical_acceleration_y) # Solve the problem while (time <= end_time): time = time + dt step = step + 1 mp.CloneTimeStep(time) mp.ProcessInfo[KratosMultiphysics.STEP] = step self.strategy.Solve() current_analytical_displacement_y += current_analytical_velocity_y * dt + 0.25 * ( current_analytical_acceleration_y + gravity) * dt**2 current_analytical_velocity_y += dt * 0.5 * ( current_analytical_acceleration_y + gravity) current_analytical_acceleration_y = gravity # ASSERT self.assertAlmostEqual(node.GetSolutionStepValue( KratosMultiphysics.ACCELERATION_Y, 0), current_analytical_acceleration_y, delta=1e-3) self.assertAlmostEqual(node.GetSolutionStepValue( KratosMultiphysics.VELOCITY_Y, 0), current_analytical_velocity_y, delta=1e-3) self.assertAlmostEqual(node.GetSolutionStepValue( KratosMultiphysics.DISPLACEMENT_Y, 0), current_analytical_displacement_y, delta=1e-3)
def ComputeDeltaTime(self): if self.dynamic_settings["time_step_prediction_level"].GetInt() > 1: self.delta_time = StructuralMechanicsApplication.CalculateDeltaTime(self.GetComputingModelPart(), self.delta_time_settings) return self.delta_time
def ExecuteBeforeSolutionLoop(self): """ This method is executed before starting the time loop Keyword arguments: self -- It signifies an instance of a class. """ import KratosMultiphysics.kratos_utilities as kratos_utils if kratos_utils.CheckIfApplicationsAvailable( "ExternalSolversApplication"): from KratosMultiphysics import ExternalSolversApplication elif kratos_utils.CheckIfApplicationsAvailable( "EigenSolversApplication"): from KratosMultiphysics import EigenSolversApplication else: raise Exception( "ExternalSolversApplication or EigenSolversApplication not available" ) # The general damping ratios damping_ratio_0 = self.settings["damping_ratio_0"].GetDouble() damping_ratio_1 = self.settings["damping_ratio_1"].GetDouble() # We get the model parts which divide the problem current_process_info = self.main_model_part.ProcessInfo existing_computation = current_process_info.Has(SMA.EIGENVALUE_VECTOR) # Create auxiliar parameters compute_damping_coefficients_settings = KM.Parameters(""" { "echo_level" : 0, "damping_ratio_0" : 0.0, "damping_ratio_1" : -1.0, "eigen_values_vector" : [0.0] } """) # Setting custom parameters compute_damping_coefficients_settings["echo_level"].SetInt( self.settings["echo_level"].GetInt()) compute_damping_coefficients_settings["damping_ratio_0"].SetDouble( damping_ratio_0) compute_damping_coefficients_settings["damping_ratio_1"].SetDouble( damping_ratio_1) # We check if the values are previously defined properties = self.main_model_part.GetProperties() for prop in properties: if prop.Has(SMA.SYSTEM_DAMPING_RATIO): self.settings["damping_ratio_0"].SetDouble( prop.GetValue(SMA.SYSTEM_DAMPING_RATIO)) break for prop in properties: if prop.Has(SMA.SECOND_SYSTEM_DAMPING_RATIO): self.settings["damping_ratio_1"].SetDouble( prop.GetValue(SMA.SECOND_SYSTEM_DAMPING_RATIO)) break # We have computed already the eigen values current_process_info = self.main_model_part.ProcessInfo precomputed_eigen_values = self.settings[ "eigen_values_vector"].GetVector() if len(precomputed_eigen_values) > 1: compute_damping_coefficients_settings[ "eigen_values_vector"].SetVector(precomputed_eigen_values) else: # If not computed eigen values already if not existing_computation: KM.Logger.PrintInfo( "::[MechanicalSolver]::", "EIGENVALUE_VECTOR not previously computed. Computing automatically, take care" ) from KratosMultiphysics import eigen_solver_factory eigen_linear_solver = eigen_solver_factory.ConstructSolver( self.settings["eigen_system_settings"]) builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver( eigen_linear_solver) eigen_scheme = SMA.EigensolverDynamicScheme() eigen_solver = SMA.EigensolverStrategy(self.main_model_part, eigen_scheme, builder_and_solver) eigen_solver.Solve() # Setting the variable RESET_EQUATION_IDS current_process_info[SMA.RESET_EQUATION_IDS] = True eigenvalue_vector = current_process_info.GetValue( SMA.EIGENVALUE_VECTOR) compute_damping_coefficients_settings[ "eigen_values_vector"].SetVector(eigenvalue_vector) # We compute the coefficients coefficients_vector = SMA.ComputeDampingCoefficients( compute_damping_coefficients_settings) # We set the values if self.settings["write_on_properties"].GetBool(): for prop in self.main_model_part.Properties: prop.SetValue(SMA.RAYLEIGH_ALPHA, coefficients_vector[0]) if current_process_info.Has(KM.COMPUTE_LUMPED_MASS_MATRIX): if current_process_info[KM.COMPUTE_LUMPED_MASS_MATRIX]: prop.SetValue(SMA.RAYLEIGH_BETA, 0.0) else: prop.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1]) else: prop.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1]) else: current_process_info.SetValue(SMA.RAYLEIGH_ALPHA, coefficients_vector[0]) if current_process_info.Has(KM.COMPUTE_LUMPED_MASS_MATRIX): if current_process_info[KM.COMPUTE_LUMPED_MASS_MATRIX]: current_process_info.SetValue(SMA.RAYLEIGH_BETA, 0.0) else: current_process_info.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1]) else: current_process_info.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1])
def ExecuteInitialize(self): sprism_neighbour_search = SMA.PrismNeighboursProcess(self.model_part) sprism_neighbour_search.Execute()
def _create_dynamic_explicit_strategy(mp): scheme = StructuralMechanicsApplication.ExplicitCentralDifferencesScheme(0.00,0.00,0.00) strategy = StructuralMechanicsApplication.MechanicalExplicitStrategy(mp,scheme,0,0,1) strategy.SetEchoLevel(0) return strategy
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 volumetric_strain_dofs = False if convergence_criterion_parameters.Has("volumetric_strain_dofs"): if convergence_criterion_parameters["volumetric_strain_dofs"].GetBool(): volumetric_strain_dofs = True # Convergence criteria if there are rotation DOFs in the problem if(rotation_dofs): if(convergence_crit == "displacement_criterion"): self.mechanical_convergence_criterion = KratosMultiphysics.MixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.ROTATION, 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 = KratosMultiphysics.MixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.ROTATION, 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 = KratosMultiphysics.MixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.ROTATION, 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 if there are volumetric strain DOFs in the problem elif(volumetric_strain_dofs): other_dof_name = "VOLUMETRIC_STRAIN" if(convergence_crit == "displacement_criterion"): self.mechanical_convergence_criterion = KratosMultiphysics.MixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.VOLUMETRIC_STRAIN, 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, other_dof_name) self.mechanical_convergence_criterion.SetEchoLevel(echo_level) elif(convergence_crit == "and_criterion"): Displacement = KratosMultiphysics.MixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.VOLUMETRIC_STRAIN, D_RT, D_AT)]) Displacement.SetEchoLevel(echo_level) Residual = StructuralMechanicsApplication.ResidualDisplacementAndOtherDoFCriteria(R_RT, R_AT, other_dof_name) Residual.SetEchoLevel(echo_level) self.mechanical_convergence_criterion = KratosMultiphysics.AndCriteria(Residual, Displacement) elif(convergence_crit == "or_criterion"): Displacement = KratosMultiphysics.MixedGenericCriteria( [(KratosMultiphysics.DISPLACEMENT, D_RT, D_AT), (KratosMultiphysics.VOLUMETRIC_STRAIN, D_RT, D_AT)]) Displacement.SetEchoLevel(echo_level) Residual = StructuralMechanicsApplication.ResidualDisplacementAndOtherDoFCriteria(R_RT, R_AT, other_dof_name) 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\"" raise Exception(err_msg)
def create_constitutive_Law(): return StructuralMechanicsApplication.HyperElastic3DLaw()
def _create_solution_scheme(self): self.scheme_settings.AddValue("rotation_dofs", self.settings["rotation_dofs"]) return StructuralMechanicsApplication.AdjointStructuralStaticScheme( self.scheme_settings, self.response_function)
def create_constitutive_Law(): return StructuralMechanicsApplication.ElasticPlaneStressUncoupledShear2DLaw( )
def _apply_material_properties(self,mp): cl = StructuralMechanicsApplication.LinearElasticPlaneStress2DLaw() mp.GetProperties()[1].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW,cl) mp.GetProperties()[1].SetValue(KratosMultiphysics.DENSITY,2000) mp.GetProperties()[1].SetValue(KratosMultiphysics.YOUNG_MODULUS,10000) mp.GetProperties()[1].SetValue(StructuralMechanicsApplication.CROSS_AREA,1.0)
def create_constitutive_Law(): return StructuralMechanicsApplication.LinearIsotropicDamage3DLaw()
def ExecuteFinalize(self): StructuralMechanicsApplication.PostprocessEigenvaluesProcess( self.model_part, self.settings).Execute()