constitutive_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_CONSTITUTIVE_3D_LAW_H_INCLUDED)
#define  KRATOS_CONSTITUTIVE_3D_LAW_H_INCLUDED
 
// System includes
#include <iostream>
#include <cmath>
 
// External includes
 
// Project includes
#include "includes/constitutive_law.h"
#include "custom_utilities/constitutive_model_utilities.hpp"
#include "custom_models/constitutive_model_data.hpp"
 
namespace Kratos
{
  class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) Constitutive3DLaw : public ConstitutiveLaw
  {
  protected:
 
    using VoigtIndexType = const unsigned int(*)[2];
 
  public:
 
    typedef ProcessInfo                                           ProcessInfoType;
    typedef ConstitutiveLaw                                              BaseType;
    typedef ConstitutiveModelData::SizeType                              SizeType;
 
    typedef ConstitutiveModelData::VectorType                          VectorType;
    typedef ConstitutiveModelData::MatrixType                          MatrixType;
    typedef ConstitutiveModelData::ModelData                        ModelDataType;
    typedef ConstitutiveModelData::ConstitutiveLawData                LawDataType;
 
    KRATOS_CLASS_POINTER_DEFINITION( Constitutive3DLaw );
 
 
    Constitutive3DLaw();
 
    Constitutive3DLaw(const Constitutive3DLaw& rOther);
 
    ConstitutiveLaw::Pointer Clone() const override;
 
    Constitutive3DLaw& operator=(const Constitutive3DLaw& rOther);
 
    ~Constitutive3DLaw() override;
 
 
 
 
    void InitializeMaterial(const Properties& rProperties,
                const GeometryType& rElementGeometry,
                const Vector& rShapeFunctionsValues ) override;
 
 
    void CalculateMaterialResponsePK1(Parameters & rValues) override;
 
    void CalculateMaterialResponsePK2(Parameters & rValues) override;
 
    void CalculateMaterialResponseKirchhoff (Parameters & rValues) override;
 
 
    void CalculateMaterialResponseCauchy (Parameters & rValues) override;
 
 
 
    void InitializeMaterialResponsePK1 (Parameters& rValues) override;
 
    void InitializeMaterialResponsePK2 (Parameters& rValues) override;
 
    void InitializeMaterialResponseKirchhoff (Parameters& rValues) override;
 
    void InitializeMaterialResponseCauchy (Parameters& rValues) override;
 
 
    void FinalizeMaterialResponsePK1(Parameters & rValues) override;
 
    void FinalizeMaterialResponsePK2(Parameters & rValues) override;
 
    void FinalizeMaterialResponseKirchhoff(Parameters & rValues) override;
 
    void FinalizeMaterialResponseCauchy(Parameters & rValues) override;
 
 
    void GetLawFeatures(Features& rFeatures) override;
 
 
    int Check(const Properties& rProperties, const GeometryType& rElementGeometry, const ProcessInfo& rCurrentProcessInfo) const override;
 
 
    bool Has(const Variable<double>& rThisVariable) override;
 
    bool Has(const Variable<Vector>& rThisVariable) override;
 
    bool Has(const Variable<Matrix>& rThisVariable) override;
 
    bool Has(const Variable<array_1d<double,3> >& rThisVariable) override;
 
    bool Has(const Variable<array_1d<double,6> >& rThisVariable) override;
 
    void SetValue(const Variable<double>& rVariable,
                  const double& rValue,
                  const ProcessInfo& rCurrentProcessInfo) override;
 
    void SetValue(const Variable<Vector>& rThisVariable,
                  const Vector& rValue,
                  const ProcessInfo& rCurrentProcessInfo) override;
 
    void SetValue(const Variable<Matrix>& rThisVariable,
                  const Matrix& rValue,
                  const ProcessInfo& rCurrentProcessInfo) override;
 
    void SetValue(const Variable<array_1d<double,3> >& rThisVariable,
                  const array_1d<double,3>& rValue,
                  const ProcessInfo& rCurrentProcessInfo) override;
 
    void SetValue(const Variable<array_1d<double,6> >& rThisVariable,
                  const array_1d<double,6>& rValue,
                  const ProcessInfo& rCurrentProcessInfo) override;
 
    double& GetValue(const Variable<double>& rThisVariable, double& rValue) override;
 
    Vector& GetValue(const Variable<Vector>& rThisVariable, Vector& rValue) override;
 
    Matrix& GetValue(const Variable<Matrix>& rThisVariable, Matrix& rValue) override;
 
    array_1d<double,3>& GetValue(const Variable<array_1d<double,3> >& rThisVariable, array_1d<double,3>& rValue) override;
 
    array_1d<double,6>& GetValue(const Variable<array_1d<double,6> >& rThisVariable, array_1d<double,6>& rValue) override;
 
    int& CalculateValue(Parameters& rParameterValues, const Variable<int>& rThisVariable, int& rValue) override;
 
    double& CalculateValue(Parameters& rParameterValues, const Variable<double>& rThisVariable, double& rValue) override;
 
    Vector& CalculateValue(Parameters& rParameterValues, const Variable<Vector>& rThisVariable, Vector& rValue) override;
 
    Matrix& CalculateValue(Parameters& rParameterValues, const Variable<Matrix>& rThisVariable, Matrix& rValue) override;
 
    array_1d<double, 3 > & CalculateValue(Parameters& rParameterValues, const Variable<array_1d<double,3> >& rVariable, array_1d<double,3> & rValue) override;
 
    array_1d<double, 6 > & CalculateValue(Parameters& rParameterValues, const Variable<array_1d<double,6> >& rVariable, array_1d<double,6> & rValue) override;
 
 
 
    SizeType WorkingSpaceDimension() override
    {
      return 3;
    };
 
    SizeType GetStrainSize() const override
    {
      return 6;
    };
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "Constitutive3DLaw";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "Constitutive3DLaw";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "Constitutive3DLaw Data";
    }
 
 
 
 
 
 
  protected:
 
 
 
 
 
    virtual void CalculateValue (Parameters & rValues, ModelDataType& rModelValues);
 
    virtual void CalculateMaterialResponsePK1 (Parameters & rValues, ModelDataType& rModelValues);
 
    virtual void CalculateMaterialResponsePK2 (Parameters & rValues, ModelDataType& rModelValues);
 
    virtual void CalculateMaterialResponseKirchhoff (Parameters & rValues, ModelDataType& rModelValues);
 
 
    virtual void CalculateMaterialResponseCauchy (Parameters & rValues, ModelDataType& rModelValues);
 
 
 
    virtual VoigtIndexType GetVoigtIndexTensor()
    {
      return this->msIndexVoigt3D6C;
    }
 
    virtual void InitializeModelData(Parameters& rValues, ModelDataType& rModelValues);
 
    virtual void FinalizeModelData(Parameters& rValues, ModelDataType& rModelValues);
 
    virtual void CalculateDomainVariables(Parameters& rValues, ModelDataType& rModelValues);
 
    virtual double& CalculateDomainVariable(Parameters& rValues, const Variable<double>& rThisVariable, double& rVariable);
 
 
    virtual double& CalculateDomainTemperature(Parameters& rValues, double& rTemperature);
 
    virtual double& CalculateDomainPressure (Parameters& rValues, double& rPressure);
 
 
    virtual bool CheckParameters(Parameters& rValues);
 
 
 
  private:
 
 
 
 
    using ConstitutiveLaw::CalculateValue;
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, ConstitutiveLaw )
    }
 
    void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, ConstitutiveLaw )
    }
 
 
 
 
 
  }; // Class Constitutive3DLaw
 
 
 
 
 
 
 
}  // namespace Kratos.
#endif // KRATOS_ELASTIC_CONSTITUTIVE_3D_LAW_H_INCLUDED  defined