incompressible_hypo_elastic_model.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosConstitutiveModelsApplication $
//   Created by:          $Author:                JMCarbonell $
//   Last modified by:    $Co-Author:                         $
//   Date:                $Date:                   April 2018 $
//   Revision:            $Revision:                      0.0 $
//
//
 
#if !defined(KRATOS_INCOMPRESSIBLE_HYPO_ELASTIC_MODEL_H_INCLUDED)
#define  KRATOS_INCOMPRESSIBLE_HYPO_ELASTIC_MODEL_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_models/elasticity_models/isochoric_hypo_elastic_model.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
  class KRATOS_API(CONSTITUTIVE_MODELS_APPLICATION) IncompressibleHypoElasticModel : public IsochoricHypoElasticModel
  {
  public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION( IncompressibleHypoElasticModel );
 
 
    IncompressibleHypoElasticModel() : IsochoricHypoElasticModel() {}
 
    IncompressibleHypoElasticModel(IncompressibleHypoElasticModel const& rOther) : IsochoricHypoElasticModel(rOther) {}
 
    IncompressibleHypoElasticModel& operator=(IncompressibleHypoElasticModel const& rOther)
    {
    HypoElasticModel::operator=(rOther);
    return *this;
    }
 
    ConstitutiveModel::Pointer Clone() const override
    {
      return Kratos::make_shared<IncompressibleHypoElasticModel>(*this);
    }
 
    ~IncompressibleHypoElasticModel() override {}
 
 
 
 
 
 
    // Simplyfied methods must be implemented for performance purposes
 
    //************************************************************************************
    //************************************************************************************
 
    int Check(const Properties& rProperties, const ProcessInfo& rCurrentProcessInfo) override
    {
      KRATOS_TRY
 
      if(YOUNG_MODULUS.Key() == 0 || rProperties[YOUNG_MODULUS] <= 0.00)
        KRATOS_ERROR << "YOUNG_MODULUS has Key zero or invalid value" << std::endl;
 
      if(POISSON_RATIO.Key() == 0){
        KRATOS_ERROR << "POISSON_RATIO has Key zero invalid value" << std::endl;
      }
      else{
        const double& nu = rProperties[POISSON_RATIO];
        if( nu < -0.999 && nu > -1.01 )
          KRATOS_ERROR << "POISSON_RATIO has an invalid value" << std::endl;
      }
 
      return 0;
 
 
      KRATOS_CATCH(" ")
    }
 
 
 
    void GetDomainVariablesList(std::vector<Variable<double> >& rScalarVariables,
                                std::vector<Variable<array_1d<double,3> > >& rComponentVariables) override
    {
      KRATOS_TRY
 
      HypoElasticModel::GetDomainVariablesList(rScalarVariables, rComponentVariables);
 
      rScalarVariables.push_back(PRESSURE);
 
      KRATOS_CATCH(" ")
    }
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "IncompressibleHypoElasticModel";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "IncompressibleHypoElasticModel";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "IncompressibleHypoElasticModel Data";
    }
 
 
 
 
  protected:
 
 
 
 
 
 
 
 
    void CalculateAndAddVolumetricStressTensor(ElasticDataType& rVariables, VectorType& rStrainVector, VectorType& rStressVector) override
    {
      KRATOS_TRY
 
      const ModelDataType& rValues = rVariables.GetModelData();
 
      //volumetric stress
      const double& Pressure = rValues.GetPressure();
      for(unsigned int i = 0; i < 3; i++)
        rStressVector[i] += Pressure;
 
      KRATOS_CATCH(" ")
    }
 
 
    // set the default volumetric function for the incompressible case
 
    void CalculateAndAddVolumetricStrainEnergy(ElasticDataType& rVariables, double& rVolumetricDensityFunction) override
    {
      KRATOS_TRY
 
      KRATOS_ERROR << "calling the class function in IncompressibleHypoElasticModel ... illegal operation" << std::endl;
 
      KRATOS_CATCH(" ")
    }
 
 
 
 
 
 
 
 
 
  private:
 
 
 
 
 
 
 
 
 
 
 
    friend class Serializer;
 
 
    void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, HypoElasticModel )
    }
 
    void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, HypoElasticModel )
    }
 
 
 
 
 
  }; // Class IncompressibleHypoElasticModel
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_INCOMPRESSIBLE_HYPO_ELASTIC_MODEL_H_INCLUDED  defined