Ejemplo n.º 1
0
    def _apply_solid_material_properties(self, mp):
        #define properties
        mp.GetProperties()[1].SetValue(KratosMultiphysics.YOUNG_MODULUS, 100e3)
        mp.GetProperties()[1].SetValue(KratosMultiphysics.POISSON_RATIO, 0.3)
        mp.GetProperties()[1].SetValue(KratosMultiphysics.THICKNESS, 1.0)
        mp.GetProperties()[1].SetValue(KratosMultiphysics.DENSITY, 1.0)

        cl = StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw()

        mp.GetProperties()[1].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW, cl)
Ejemplo n.º 2
0
    def _apply_material_properties(self, mp, dim, small_strain = True):
        #define properties
        mp.GetProperties()[1].SetValue(KratosMultiphysics.YOUNG_MODULUS,210)
        mp.GetProperties()[1].SetValue(KratosMultiphysics.POISSON_RATIO,0.3)
        mp.GetProperties()[1].SetValue(KratosMultiphysics.THICKNESS,1.0)
        mp.GetProperties()[1].SetValue(KratosMultiphysics.DENSITY,1.0)

        g = [0,-10.0,0]
        mp.GetProperties()[1].SetValue(KratosMultiphysics.VOLUME_ACCELERATION,g)

        cl = StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw()
        mp.GetProperties()[1].SetValue(KratosMultiphysics.CONSTITUTIVE_LAW,cl)
Ejemplo n.º 3
0
    def _apply_material_properties(self, mp, dim, small_strain=True):
        #define properties
        mp.GetProperties()[1].SetValue(KM.YOUNG_MODULUS, 210)
        mp.GetProperties()[1].SetValue(KM.POISSON_RATIO, 0.3)
        mp.GetProperties()[1].SetValue(KM.THICKNESS, 1.0)
        mp.GetProperties()[1].SetValue(KM.DENSITY, 1.0)

        g = [0, -10.0, 0]
        mp.GetProperties()[1].SetValue(KM.VOLUME_ACCELERATION, g)

        cl = SMA.LinearElasticPlaneStrain2DLaw()
        mp.GetProperties()[1].SetValue(KM.CONSTITUTIVE_LAW, cl)
Ejemplo n.º 4
0
    def _apply_material_properties(self, dim):
        #define properties
        self.mp.GetProperties()[1].SetValue(KM.YOUNG_MODULUS, 210e9)
        self.mp.GetProperties()[1].SetValue(KM.POISSON_RATIO, 0.3)
        self.mp.GetProperties()[1].SetValue(KM.THICKNESS, 1.0)
        self.mp.GetProperties()[1].SetValue(KM.DENSITY, 1.0)

        g = [0, 0, 0]
        self.mp.GetProperties()[1].SetValue(KM.VOLUME_ACCELERATION, g)

        self.mp.ProcessInfo[KM.DOMAIN_SIZE] = dim
        if dim == 2:
            cl = SMA.LinearElasticPlaneStrain2DLaw()
        else:
            cl = SMA.LinearElastic3DLaw()
        self.mp.GetProperties()[1].SetValue(KM.CONSTITUTIVE_LAW, cl)
    def _apply_material_properties(self, ModelPart, Dimension):
        # Define material properties
        ModelPart.GetProperties()[1].SetValue(KratosMultiphysics.YOUNG_MODULUS,
                                              200.0e9)
        ModelPart.GetProperties()[1].SetValue(KratosMultiphysics.POISSON_RATIO,
                                              0.4)
        ModelPart.GetProperties()[1].SetValue(KratosMultiphysics.DENSITY, 1.0)

        # Define body force
        g = [0, 0, 0]
        ModelPart.GetProperties()[1].SetValue(
            KratosMultiphysics.VOLUME_ACCELERATION, g)

        # Define constitutive law
        if (Dimension == 2):
            cons_law = StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw(
            )
        else:
            cons_law = StructuralMechanicsApplication.LinearElastic3DLaw()
        ModelPart.GetProperties()[1].SetValue(
            KratosMultiphysics.CONSTITUTIVE_LAW, cons_law)
    def test_specifications_utilities_elements_dependencies(self):
        current_model = KratosMultiphysics.Model()

        model_part = current_model.CreateModelPart("Main")

        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, 1.0, 1.0, 0.0)
        prop1 = KratosMultiphysics.Properties(1)
        model_part.AddProperties(prop1)
        prop1.SetValue(
            KratosMultiphysics.CONSTITUTIVE_LAW,
            StructuralMechanicsApplication.LinearElasticPlaneStrain2DLaw())
        elem1 = model_part.CreateNewElement("SmallDisplacementElement2D3N", 1,
                                            [1, 2, 3],
                                            model_part.GetProperties()[1])
        elem1.Initialize(model_part.ProcessInfo)

        self.assertEqual(model_part.GetNodalSolutionStepDataSize(), 0)
        KratosMultiphysics.SpecificationsUtilities.AddMissingVariables(
            model_part)
        self.assertEqual(model_part.GetNodalSolutionStepDataSize(), 3)

        self.assertEqual(node1.HasDofFor(KratosMultiphysics.DISPLACEMENT_X),
                         False)
        self.assertEqual(node1.HasDofFor(KratosMultiphysics.DISPLACEMENT_Y),
                         False)
        self.assertEqual(node1.HasDofFor(KratosMultiphysics.DISPLACEMENT_Z),
                         False)
        KratosMultiphysics.SpecificationsUtilities.AddMissingDofs(model_part)
        self.assertEqual(node1.HasDofFor(KratosMultiphysics.DISPLACEMENT_X),
                         True)
        self.assertEqual(node1.HasDofFor(KratosMultiphysics.DISPLACEMENT_Y),
                         True)
        self.assertEqual(node1.HasDofFor(KratosMultiphysics.DISPLACEMENT_Z),
                         True)

        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.
            DetermineTimeIntegration(model_part).sort(),
            ['explicit', 'static', 'implicit'].sort())
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.DetermineFramework(
                model_part), "lagrangian")
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.DetermineSymmetricLHS(
                model_part), True)
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.
            DeterminePositiveDefiniteLHS(model_part), True)
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.
            DetermineIfCompatibleGeometries(model_part), True)
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.
            DetermineIfRequiresTimeIntegration(model_part), True)
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.
            CheckCompatibleConstitutiveLaws(model_part), True)
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.
            CheckGeometricalPolynomialDegree(model_part), -1)
        docu = KratosMultiphysics.Parameters(
            """{"SmallDisplacementElement2D3N"   : "This is a pure displacement element"}"""
        )
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.GetDocumention(
                model_part).IsEquivalentTo(docu), True)

        # Changing the law to get a False check
        prop1.SetValue(
            KratosMultiphysics.CONSTITUTIVE_LAW,
            StructuralMechanicsApplication.LinearElasticPlaneStress2DLaw())
        elem1.Initialize(model_part.ProcessInfo)
        self.assertEqual(
            KratosMultiphysics.SpecificationsUtilities.
            CheckCompatibleConstitutiveLaws(model_part), False)