large_strain_3D_law.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosConstitutiveModelsApplication $
//   Created by:          $Author:                JMCarbonell $
//   Last modified by:    $Co-Author:                         $
//   Date:                $Date:                   April 2017 $
//   Revision:            $Revision:                      0.0 $
//
//
 
#if !defined (KRATOS_LARGE_STRAIN_3D_LAW_H_INCLUDED)
#define  KRATOS_LARGE_STRAIN_3D_LAW_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_laws/constitutive_3D_law.hpp"
#include "custom_models/constitutive_model.hpp"
 
namespace Kratos
{
  class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) LargeStrain3DLaw : public Constitutive3DLaw
  {
  public:
 
 
    typedef ConstitutiveModel                                     ModelType; //large_strain model
    typedef ModelType::Pointer                             ModelTypePointer;
 
    KRATOS_CLASS_POINTER_DEFINITION( LargeStrain3DLaw );
 
 
    LargeStrain3DLaw();
 
    LargeStrain3DLaw(ModelTypePointer pModel);
 
    LargeStrain3DLaw(const LargeStrain3DLaw& rOther);
 
    LargeStrain3DLaw& operator=(LargeStrain3DLaw const& rOther);
 
    ConstitutiveLaw::Pointer Clone() const override;
 
    ~LargeStrain3DLaw() override;
 
 
 
 
    void InitializeMaterial(const Properties& rProperties,
                const GeometryType& rElementGeometry,
                const Vector& rShapeFunctionsValues ) override;
 
    void CalculateMaterialResponsePK2(Parameters & rValues) override;
 
    void CalculateMaterialResponseKirchhoff (Parameters & rValues) override;
 
 
    void GetLawFeatures(Features& rFeatures) override;
 
 
    void GetModelFeatures(Features& rFeatures);
 
 
    int Check(const Properties& rProperties, const GeometryType& rElementGeometry, const ProcessInfo& rCurrentProcessInfo) const override;
 
 
    bool Has( const Variable<double>& rThisVariable ) override;
 
    void SetValue( const Variable<double>& rVariable,
                   const double& rValue,
                   const ProcessInfo& rCurrentProcessInfo ) override;
 
    void SetValue( const Variable<Vector>& rVariable,
                   const Vector& rValue,
                   const ProcessInfo& rCurrentProcessInfo ) override;
 
    void SetValue( const Variable<Matrix>& rVariable,
                   const Matrix& rValue,
                   const ProcessInfo& rCurrentProcessInfo ) override;
 
    double& GetValue( const Variable<double>& rThisVariable, double& rValue )  override;
 
    Matrix& GetValue( const Variable<Matrix>& rThisVariable, Matrix& rValue )  override;
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "LargeStrain3DLaw";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "LargeStrain3DLaw";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "LargeStrain3DLaw Data";
      mpModel->PrintData(rOStream);
    }
 
 
 
 
 
 
  protected:
 
 
 
    //constitutive model
    ModelTypePointer mpModel;
 
    //internal elastic variables
 
    //stored total deformation gradient for incremental strain update
    double        mTotalDeformationDet;
    MatrixType    mInverseTotalDeformationMatrix;
 
 
 
 
    void CalculateMaterialResponsePK2(Parameters & rValues, ModelDataType& rModelValues) override;
 
    void CalculateMaterialResponseKirchhoff (Parameters & rValues, ModelDataType& rModelValues) override;
 
 
    void InitializeModelData(Parameters& rValues, ModelDataType& rModelValues) override;
 
 
    void FinalizeModelData(Parameters& rValues, ModelDataType& rModelValues) override;
 
    virtual void CalculateStressVector(ModelDataType& rModelValues, Vector& rStressVector);
 
 
    virtual void CalculateConstitutiveMatrix(ModelDataType& rModelValues, Matrix& rConstitutiveMatrix);
 
 
    virtual void CalculateStressVectorAndConstitutiveMatrix(ModelDataType& rModelValues, Vector& rStressVector, Matrix& rConstitutiveMatrix);
 
 
 
  private:
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, Constitutive3DLaw )
 
      rSerializer.save("mpModel",mpModel);
      rSerializer.save("mTotalDeformationDet",mTotalDeformationDet);
      rSerializer.save("mInverseTotalDeformationMatrix",mInverseTotalDeformationMatrix);
    }
 
    void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, Constitutive3DLaw )
 
      rSerializer.load("mpModel",mpModel);
      rSerializer.load("mTotalDeformationDet",mTotalDeformationDet);
      rSerializer.load("mInverseTotalDeformationMatrix",mInverseTotalDeformationMatrix);
    }
 
 
 
 
 
 
  }; // Class LargeStrain3DLaw
 
 
 
 
 
 
 
}  // namespace Kratos.
#endif // KRATOS_LARGE_STRAIN_3D_LAW_H_INCLUDED  defined