updated_lagrangian_segregated_fluid_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_FLUID_ELEMENT_H_INCLUDED)
#define  KRATOS_UPDATED_LAGRANGIAN_SEGREGATED_FLUID_ELEMENT_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_elements/fluid_elements/fluid_element.hpp"
 
 
namespace Kratos
{
 
 
class KRATOS_API(PFEM_APPLICATION) UpdatedLagrangianSegregatedFluidElement : public FluidElement
{
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( UpdatedLagrangianSegregatedFluidElement );
 
  enum StepType{VELOCITY_STEP = 0, PRESSURE_STEP = 1};
 
 
  UpdatedLagrangianSegregatedFluidElement();
 
  UpdatedLagrangianSegregatedFluidElement(IndexType NewId, GeometryType::Pointer pGeometry);
 
  UpdatedLagrangianSegregatedFluidElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
  UpdatedLagrangianSegregatedFluidElement(UpdatedLagrangianSegregatedFluidElement const& rOther);
 
 
  virtual ~UpdatedLagrangianSegregatedFluidElement();
 
 
  UpdatedLagrangianSegregatedFluidElement& operator=(UpdatedLagrangianSegregatedFluidElement 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;
 
  //************* STARTING - ENDING  METHODS
 
  void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
  void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
  void InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
  void FinalizeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
  //************* GETTING METHODS
 
  void GetDofList(DofsVectorType& rElementalDofList, const ProcessInfo& rCurrentProcessInfo) const override;
 
  void EquationIdVector(EquationIdVectorType& rResult, const ProcessInfo& rCurrentProcessInfo) const override;
 
  void GetValuesVector(Vector& rValues, int Step = 0) const override;
 
  void GetFirstDerivativesVector(Vector& rValues, int Step = 0) const override;
 
  void GetSecondDerivativesVector(Vector& rValues, int Step = 0) const override;
 
 
  void CalculateMassMatrix(MatrixType& rMassMatrix,
                           const ProcessInfo& rCurrentProcessInfo) override;
 
  void CalculateDampingMatrix(MatrixType& rDampingMatrix,
                              const ProcessInfo& rCurrentProcessInfo) override;
 
 
 
  //************************************************************************************
  //************************************************************************************
  int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
  std::string Info() const override
  {
    std::stringstream buffer;
    buffer << "Updated Lagrangian Fluid Element #" << Id();
    return buffer.str();
  }
 
  void PrintInfo(std::ostream& rOStream) const override
  {
    rOStream << "Updated Lagrangian Fluid Element #" << Id();
  }
 
  void PrintData(std::ostream& rOStream) const override
  {
    GetGeometry().PrintData(rOStream);
  }
 
protected:
 
  StepType mStepVariable;
 
 
  void SetProcessInformation(const ProcessInfo& rCurrentProcessInfo) override;
 
  void InitializeElementData(ElementDataType & rVariables,
                             const ProcessInfo& rCurrentProcessInfo) override;
 
  void GetStepAlpha(double& rAlpha);
 
  void CalculateKinematics(ElementDataType& rVariables,
                           const double& rPointNumber) override;
 
  void CalculateAndAddLHS(LocalSystemComponents& rLocalSystem,
                          ElementDataType& rVariables) override;
 
  void CalculateAndAddRHS(LocalSystemComponents& rLocalSystem,
                          ElementDataType& rVariables) override;
 
 
  void CalculateAndAddDynamicLHS(MatrixType& rLeftHandSideMatrix,
                                 ElementDataType& rVariables) override;
 
  void CalculateAndAddDynamicRHS(VectorType& rRightHandSideVector,
                                 ElementDataType& rVariables) override;
 
  unsigned int GetDofsSize() const override;
 
  void CalculateAndAddKvvm(MatrixType& rLeftHandSideMatrix,
                           ElementDataType& rVariables) override;
 
  void CalculateAndAddKvvg(MatrixType& rLeftHandSideMatrix,
                           ElementDataType& rVariables) override;
 
 
  void CalculateAndAddKpp(MatrixType& rLeftHandSideMatrix,
                          ElementDataType& rVariables);
 
  void CalculateAndAddInternalForces(VectorType& rRightHandSideVector,
                                     ElementDataType & rVariables) override;
 
  void CalculateAndAddPressureForces(VectorType& rRightHandSideVector,
                                     ElementDataType & rVariables);
 
  void AddVolumetricPart(Vector& rStressVector, const double& rMeanPressure);
 
  void RemoveVolumetricPart(Vector& rStressVector, const double& rMeanPressure);
 
  void AddVolumetricPart(Matrix& rConstitutiveMatrix, const double& rBulkFactor);
 
  void RemoveVolumetricPart(Matrix& rConstitutiveMatrix, const double& rBulkFactor);
 
  void CalculateDenseMatrixMeanValue(MatrixType& rMatrix, double& rMeanValue);
 
  void CalculateLumpedMatrixMeanValue(MatrixType& rMatrix, double& rMeanValue);
 
  void CalculateStiffnessFactor(MatrixType& rLeftHandSideMatrix,
                                ElementDataType& rVariables,
                                const double& rBulkFactor,
                                double& rStiffnessFactor);
  void SetElementData(ElementDataType& rVariables,
                      ConstitutiveLaw::Parameters& rValues,
                      const int & rPointNumber) override;
 
  void CalculateMaterialResponse(ElementDataType& rVariables,
                                 ConstitutiveLaw::Parameters& rValues,
                                 const int & rPointNumber) 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);
 
 
  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 UpdatedLagrangianSegregatedFluidElement
 
 
} // namespace Kratos.
#endif // KRATOS_UPDATED_LAGRANGIAN_SEGREGATED_FLUID_ELEMENT_H_INCLUDED  defined