non_linear_hencky_plastic_3D_law.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosPfemSolidMechanicsApplication $
//   Created by:          $Author:                  LMonforte $
//   Last modified by:    $Co-Author:                         $
//   Date:                $Date:                    July 2015 $
//   Revision:            $Revision:                      0.0 $
//
//
 
#if !defined (KRATOS_NON_LINEAR_HENCKY_PLASTIC_3D_LAW_H_INCLUDED)
#define KRATOS_NON_LINEAR_HENCKY_PLASTIC_3D_LAW_H_INCLUDED
 
 
// System includes
 
// External includes
 
// Project includes
#include "custom_constitutive/hyperelastic_plastic_3D_law.hpp"
 
#include "pfem_solid_mechanics_application_variables.h"
 
namespace Kratos
{
class KRATOS_API(PFEM_SOLID_MECHANICS_APPLICATION) NonLinearHenckyElasticPlastic3DLaw: public HyperElasticPlastic3DLaw
{
 
public:
    typedef ProcessInfo      ProcessInfoType;
    typedef ConstitutiveLaw         BaseType;
    typedef std::size_t             SizeType;
 
    typedef FlowRule::Pointer                FlowRulePointer;
    typedef YieldCriterion::Pointer    YieldCriterionPointer;
    typedef HardeningLaw::Pointer        HardeningLawPointer;
    typedef Properties::Pointer            PropertiesPointer;
 
    KRATOS_CLASS_POINTER_DEFINITION( NonLinearHenckyElasticPlastic3DLaw );
 
    NonLinearHenckyElasticPlastic3DLaw();
 
 
    NonLinearHenckyElasticPlastic3DLaw(FlowRulePointer pFlowRule, YieldCriterionPointer pYieldCriterion, HardeningLawPointer pHardeningLaw);
 
    NonLinearHenckyElasticPlastic3DLaw (const NonLinearHenckyElasticPlastic3DLaw& rOther)  ;
 
 
    //HyperElasticPlastic3DLaw& operator=(const HyperElasticPlastic3DLaw& rOther);
 
    ConstitutiveLaw::Pointer Clone() const override;
 
    virtual ~NonLinearHenckyElasticPlastic3DLaw();
 
    SizeType WorkingSpaceDimension() override
    {
        return 3;
    };
 
    SizeType GetStrainSize() const override
    {
        return 6;
    };
 
    void GetLawFeatures(Features& rFeatures) override;
 
    double& GetValue( const Variable<double>& rThisVariable, double& rValue ) override;
 
    Matrix& GetValue( const Variable<Matrix>& rThisVariable, Matrix& rValue ) override;
 
 
    void SetValue( const Variable<Vector>& rThisVariable,
                   const Vector& rValue,
                   const ProcessInfo& rCurrentProcessInfo ) override;
 
    void SetValue( const Variable<double>& rThisVariable,
                   const double& rValue,
                   const ProcessInfo& rCurrentProcessInfo ) override;
 
/*    bool Has( const Variable<double>& rThisVariable );
    bool Has( const Variable<Vector>& rThisVariable );
    bool Has( const Variable<Matrix>& rThisVariable );
 
    double& GetValue( const Variable<double>& rThisVariable, double& rValue );
    Vector& GetValue( const Variable<Vector>& rThisVariable, Vector& rValue );
    Matrix& GetValue( const Variable<Matrix>& rThisVariable, Matrix& rValue );
 
 
    void SetValue( const Variable<double>& rVariable,
                   const double& Value,
                   const ProcessInfo& rCurrentProcessInfo );
    void SetValue( const Variable<Vector>& rThisVariable,
                   const Vector& rValue,
                   const ProcessInfo& rCurrentProcessInfo );
    void SetValue( const Variable<Matrix>& rThisVariable,
                   const Matrix& rValue,
                   const ProcessInfo& rCurrentProcessInfo );
*/    
    void InitializeMaterial( const Properties& rProps,
                             const GeometryType& rGeom,
                             const Vector& rShapeFunctionsValues ) override;
 
    int Check( const Properties& rMaterialProperties, const GeometryType& rElementGeometry, const ProcessInfo& rCurrentProcessInfo) override;
 
//    void CalculateMaterialResponsePK1 (Parameters & rValues);
// Esta función sirve como está definida en la clase madre
 
//    void CalculateMaterialResponsePK2 (Parameters & rValues);
// Esta función sirve como está definida en la clase madre
 
    void CalculateMaterialResponseKirchhoff (Parameters & rValues) override;
 
 
//    void CalculateMaterialResponseCauchy (Parameters & rValues);
// Esta función sirve como está definida
 
//    void FinalizeMaterialResponsePK1 (Parameters & rValues);
 
//    void FinalizeMaterialResponsePK2 (Parameters & rValues);
 
//    void FinalizeMaterialResponseCauchy (Parameters & rValues);
 
//    int Check(const Properties& rProperties, const GeometryType& rGeometry, const ProcessInfo& rCurrentProcessInfo);
 
 
 
    //String Info() const override;
    //void PrintInfo(std::ostream& rOStream) const override;
    //void PrintData(std::ostream& rOStream) const override;
 
protected:
 
 
//    Matrix mElasticLeftCauchyGreen;
 
//    FlowRulePointer mpFlowRule;
 
//    YieldCriterionPointer mpYieldCriterion;
 
//    HardeningLawPointer   mpHardeningLaw;
 
 
    virtual Matrix SetConstitutiveMatrixToAppropiateDimension(const Matrix& rElastoPlasticTangentMatrix);
 
 
    virtual void CorrectDomainPressure( Matrix& rStressMatrix, const MaterialResponseVariables& rElasticVariables);
 
    virtual void CalculateElastoPlasticTangentMatrix( const FlowRule::RadialReturnVariables & rReturnMappingVariables, const Matrix& rNewElasticLeftCauchyGreen,const double& rAlpha, Matrix& rElastoPlasticMatrix, const MaterialResponseVariables& rElasticVariables);
 
    virtual void CalculateOnlyDeviatoricPart( Matrix& rIncrementalDeformationGradient );
 
    virtual Matrix CalculateExtraMatrix( const Matrix& rStressMatrix);
 
//    Matrix& DeformationGradient3D (Matrix & Matrix2D);
 
//    virtual void CalculateGreenLagrangeStrain( const Matrix & rRightCauchyGreen,
//            Vector& rStrainVector );
 
 
//    virtual void CalculateAlmansiStrain( const Matrix & rLeftCauchyGreen,
//                                         Vector& rStrainVector );
/*    virtual void CalculateIsochoricConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
                               const Matrix & rInverseDeformationGradientF,
                               const Vector & rIsoStressVector,
                               Matrix& rConstitutiveMatrix);
*/
 
/*    double& IsochoricConstitutiveComponent( double & rCabcd,
                                            const MaterialResponseVariables& rElasticVariables,
                                            const Matrix & rIsoStressMatrix,
                                            const unsigned int& a, const unsigned int& b,
                                            const unsigned int& c, const unsigned int& d);
*/
/*    double& IsochoricConstitutiveComponent( double & rCabcd,
                                            const MaterialResponseVariables& rElasticVariables,
                                            const Matrix & rInverseDeformationGradientF,
                        const Matrix & rIsoStressMatrix,
                        const unsigned int& a, const unsigned int& b,
                                            const unsigned int& c, const unsigned int& d);
 
*/
 
/*    virtual void CalculateVolumetricConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
             Matrix& rConstitutiveMatrix);
 
*/
/*    virtual void CalculateVolumetricConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
                            const Matrix & rInverseDeformationGradientF,
                            Matrix& rConstitutiveMatrix);
*/
 
/*    double& VolumetricConstitutiveComponent( double & rCabcd,
            const MaterialResponseVariables& rElasticVariables,
            const Vector& rFactors,
            const unsigned int& a, const unsigned int& b,
            const unsigned int& c, const unsigned int& d);
*/
/*    double& VolumetricConstitutiveComponent( double & rCabcd,
            const MaterialResponseVariables& rElasticVariables,
            const Matrix & rInverseDeformationGradientF,
            const Vector & rFactors,
            const unsigned int& a, const unsigned int& b,
            const unsigned int& c, const unsigned int& d);
 
*/
/*    virtual void CalculatePlasticConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
                             FlowRule::RadialReturnVariables & rReturnMappingVariables,
                             Matrix& rConstitutiveMatrix);
*/
 
/*    virtual void CalculatePlasticConstitutiveMatrix (const MaterialResponseVariables& rElasticVariables,
                             const Matrix & rInverseDeformationGradientF,
                             FlowRule::RadialReturnVariables & rReturnMappingVariables,
                             Matrix& rConstitutiveMatrix);
*/
 
/*    double& PlasticConstitutiveComponent( double & rCabcd,
            const MaterialResponseVariables& rElasticVariables,
            const Matrix & rIsoStressMatrix,
            const FlowRule::PlasticFactors & rScalingFactors,
            const unsigned int& a, const unsigned int& b,
            const unsigned int& c, const unsigned int& d);
*/
/*    double& PlasticConstitutiveComponent( double & rCabcd,
            const MaterialResponseVariables& rElasticVariables,
            const Matrix & rInverseDeformationGradientF,
        const Matrix & rIsoStressMatrix,
        const FlowRule::PlasticFactors & rScalingFactors,
        const unsigned int& a, const unsigned int& b,
            const unsigned int& c, const unsigned int& d);
*/
 
/*    virtual void CalculatePlasticIsochoricStress( MaterialResponseVariables & rElasticVariables,
                       FlowRule::RadialReturnVariables & rReturnMappingVariables,
                                           StressMeasure rStressMeasure,
                       Matrix& rIsoStressMatrix,
                                           Vector& rIsoStressVector);
*/
/*    virtual void CalculateVolumetricStress( const MaterialResponseVariables & rElasticVariables,
                                            Vector& rVolStressVector );
*/
 
 
//    virtual double& CalculateDomainPressure (const MaterialResponseVariables & rElasticVariables,
//                                     double & rPressure);
 
//    virtual Vector&  CalculateDomainPressureFactors (const MaterialResponseVariables & rElasticVariables,
//                       Vector & rFactors);
 
 
//    virtual bool CheckParameters(Parameters& rValues);
//Ll: a pensar què s'ha de fer amb els constructors, els CheckParameters i alguna altra funció virtual
private:
 
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, HyperElasticPlastic3DLaw )
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, HyperElasticPlastic3DLaw )
    }
 
 
 
 
}; // Class HenckyElasticPlastic3DLaw
 
} //namespace Kratos
 
#endif  //KRATOS_HENCKY_PLASTIC_3D_LAW_H_INCLUDED