updated_lagrangian_segregated_V_P_element.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:            JMCarbonell $
//   Last modified by:    $Co-Author:                     $
//   Date:                $Date:               April 2018 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_UPDATED_LAGRANGIAN_SEGREGATED_V_P_ELEMENT_H_INCLUDED)
#define  KRATOS_UPDATED_LAGRANGIAN_SEGREGATED_V_P_ELEMENT_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_elements/solid_elements/large_displacement_segregated_V_P_element.hpp"
 
 
namespace Kratos
{
 
 
class KRATOS_API(SOLID_MECHANICS_APPLICATION) UpdatedLagrangianSegregatedVPElement : public LargeDisplacementSegregatedVPElement
{
public:
 
  typedef ConstitutiveLaw ConstitutiveLawType;
  typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
  typedef ConstitutiveLawType::StressMeasure StressMeasureType;
  typedef GeometryData::IntegrationMethod IntegrationMethod;
  typedef GeometryData::SizeType SizeType;
 
  typedef GlobalPointersVector<Element> ElementWeakPtrVectorType;
 
  KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( UpdatedLagrangianSegregatedVPElement );
 
 
  UpdatedLagrangianSegregatedVPElement();
 
  UpdatedLagrangianSegregatedVPElement(IndexType NewId, GeometryType::Pointer pGeometry);
 
  UpdatedLagrangianSegregatedVPElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
  UpdatedLagrangianSegregatedVPElement(UpdatedLagrangianSegregatedVPElement const& rOther);
 
 
  ~UpdatedLagrangianSegregatedVPElement() override;
 
 
  UpdatedLagrangianSegregatedVPElement& operator=(UpdatedLagrangianSegregatedVPElement const& rOther);
 
 
  Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes, PropertiesType::Pointer pProperties) const override;
 
  Element::Pointer Clone(IndexType NewId, NodesArrayType const& ThisNodes) const override;
 
  //************* GETTING METHODS
  //SET
  void SetValuesOnIntegrationPoints(const Variable<double>& rVariable, const std::vector<double>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
  //GET:
  void CalculateOnIntegrationPoints(const Variable<double>& rVariable, std::vector<double>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
  //************* STARTING - ENDING  METHODS
  void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
 
  //************************************************************************************
  //************************************************************************************
  int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
  std::string Info() const override
  {
    std::stringstream buffer;
    buffer << "Updated Lagrangian Segregated V-P Solid Element #" << Id();
    return buffer.str();
  }
 
  void PrintInfo(std::ostream& rOStream) const override
  {
    rOStream << "Updated Lagrangian Segregated V-P Solid Element #" << Id();
  }
 
  void PrintData(std::ostream& rOStream) const override
  {
    GetGeometry().PrintData(rOStream);
  }
 
protected:
 
  std::vector< Matrix > mDeformationGradientF0;
 
  Vector mDeterminantF0;
 
 
  void FinalizeStepVariables(ElementDataType & rVariables,
                             const double& rPointNumber ) override;
 
  void InitializeElementData(ElementDataType & rVariables,
                             const ProcessInfo& rCurrentProcessInfo) override;
 
  void CalculateKinematics(ElementDataType& rVariables,
                           const double& rPointNumber) override;
 
  void CalculateKinetics(ElementDataType& rVariables,
                         const double& rPointNumber) override;
 
  void CalculateMaterialResponse(ElementDataType& rVariables,
                                 ConstitutiveLaw::Parameters& rValues,
                                 const int & rPointNumber) override;
 
  void CalculateAndAddKpp(MatrixType& rLeftHandSideMatrix,
                          ElementDataType& rVariables) override;
 
  void CalculateAndAddPressureForces(VectorType& rRightHandSideVector,
                                     ElementDataType & rVariables) override;
 
  void CalculateStabilizationTau(ElementDataType& rVariables);
 
  void GetFreeSurfaceFaces(std::vector<std::vector<SizeType> >& Faces);
 
  void GetFaceNormal(const std::vector<SizeType>& rFace, const ElementDataType & rVariables, Vector& rNormal);
 
  void GetFaceWeight(const std::vector<SizeType>& rFace, const ElementDataType & rVariables, double& rWeight, double& rNormalSize);
 
  void GetFaceNormal(const std::vector<SizeType>& rFace, Vector& rNormal);
 
 
  void GetHistoricalVariables( ElementDataType& rVariables,
                               const double& rPointNumber ) override;
 
  double& CalculateVolumeChange(double& rVolumeChange, ElementDataType& rVariables) override;
 
 
private:
 
  friend class Serializer;
 
  // A private default constructor necessary for serialization
 
  void save(Serializer& rSerializer) const override;
 
  void load(Serializer& rSerializer) override;
 
 
 
}; // Class UpdatedLagrangianSegregatedVPElement
 
 
} // namespace Kratos.
#endif // KRATOS_UPDATED_LAGRANGIAN_SEGREGATED_V_P_ELEMENT_H_INCLUDED  defined