linear_solid_element.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:            JMCarbonell $
//   Last modified by:    $Co-Author:                     $
//   Date:                $Date:                July 2013 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_LINEAR_SOLID_ELEMENT_H_INCLUDED)
#define  KRATOS_LINEAR_SOLID_ELEMENT_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/checks.h"
#include "includes/element.h"
#include "custom_utilities/solid_mechanics_math_utilities.hpp"
 
namespace Kratos
{
 
 
class KRATOS_API(SOLID_MECHANICS_APPLICATION) LinearSolidElement
    : public Element
{
public:
 
    typedef ConstitutiveLaw ConstitutiveLawType;
    typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
    typedef ConstitutiveLawType::StressMeasure StressMeasureType;
    typedef GeometryData::IntegrationMethod IntegrationMethod;
    typedef GeometryData::SizeType SizeType;
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( LinearSolidElement );
 
 
public:
 
 
 
    LinearSolidElement(IndexType NewId, GeometryType::Pointer pGeometry);
 
    LinearSolidElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
    LinearSolidElement(LinearSolidElement const& rOther);
 
    ~LinearSolidElement() override;
 
 
    LinearSolidElement& operator=(LinearSolidElement 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
 
    IntegrationMethod GetIntegrationMethod() const override;
 
    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;
 
 
 
    //on integration points:
    // see element.h
 
    void CalculateOnIntegrationPoints(const Variable<Matrix>& rVariable, std::vector<Matrix>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //************* STARTING - ENDING  METHODS
 
    void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
    void FinalizeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
    void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //************* COMPUTING  METHODS
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix,
                  VectorType& rRightHandSideVector,
                  const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateMassMatrix(MatrixType& rMassMatrix,
                             const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateDampingMatrix(MatrixType& rDampingMatrix,
                                const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void AddExplicitContribution(const VectorType& rRHSVector,
                                 const Variable<VectorType>& rRHSVariable,
                                 const Variable<array_1d<double,3> >& rDestinationVariable,
                                 const ProcessInfo& rCurrentProcessInfo) override;
 
 
 
    //************************************************************************************
    //************************************************************************************
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
 
protected:
 
    IntegrationMethod mThisIntegrationMethod;
 
    std::vector<ConstitutiveLaw::Pointer> mConstitutiveLawVector;
 
 
    LinearSolidElement() : Element() {}
 
    //constexpr const std::size_t& Dimension() const {return GetGeometry().WorkingSpaceDimension();}
 
 
 
    void ClearNodalForces ();
 
 
    Matrix& CalculateTotalDeltaPosition(Matrix & rDeltaPosition);
 
 
    void CalculateInfinitesimalStrain(Vector& rStrainVector,
                      const Matrix& rDN_DX);
 
    Vector& CalculateVolumeForce(Vector& rVolumeForce, const Vector& rN);
 
 
 
private:
 
    friend class Serializer;
 
    // A private default constructor necessary for serialization
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
 
}; // Class LinearSolidElement
 
 
} // namespace Kratos.
#endif // KRATOS_LINEAR_SOLID_ELEMENT_H_INCLUDED  defined