small_displacement_beam_element_3D2N.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:         Nelson Maireni $
//   Last modified by:    $Co-Author:         JMCarbonell $
//   Date:                $Date:            November 2015 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_SMALL_DISPLACEMENT_BEAM_ELEMENT_3D2N_H_INCLUDED)
#define  KRATOS_SMALL_DISPLACEMENT_BEAM_ELEMENT_3D2N_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/checks.h"
#include "includes/element.h"
 
namespace Kratos
{
 
 
class KRATOS_API(SOLID_MECHANICS_APPLICATION) SmallDisplacementBeamElement3D2N
    :public Element
{
public:
 
    typedef GeometryData::IntegrationMethod IntegrationMethod;
    typedef GeometryData::SizeType SizeType;
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION( SmallDisplacementBeamElement3D2N );
 
 
protected:
 
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_RHS_VECTOR );
    KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_LHS_MATRIX );
 
    struct SectionProperties
    {
 
      double Area;                            // Area or the beam section
      double Inertia_z;                       // Moment of Inertia about the local z axis, Iz local
      double Inertia_y;                       // Moment of Inertia about the local y axis, Iy local
      double Polar_Inertia;                   // Polar Moment of Inertia, measures an object's ability to resist twisting, when acted upon by differences of torque along its length.
    };
 
    struct LocalSystemComponents
    {
    private:
 
      //for calculation local system with compacted LHS and RHS
      MatrixType *mpLeftHandSideMatrix;
      VectorType *mpRightHandSideVector;
 
    public:
 
      //calculation flags
      Flags        CalculationFlags;
      MatrixType   RotationMatrix;
 
 
      void SetLeftHandSideMatrix( MatrixType& rLeftHandSideMatrix ) { mpLeftHandSideMatrix = &rLeftHandSideMatrix; };
 
      void SetRightHandSideVector( VectorType& rRightHandSideVector ) { mpRightHandSideVector = &rRightHandSideVector; };
 
 
      MatrixType& GetLeftHandSideMatrix() { return *mpLeftHandSideMatrix; };
 
      VectorType& GetRightHandSideVector() { return *mpRightHandSideVector; };
 
    };
 
 
public:
 
 
    SmallDisplacementBeamElement3D2N(IndexType NewId, GeometryType::Pointer pGeometry);
 
    SmallDisplacementBeamElement3D2N(IndexType NewId, GeometryType::Pointer pGeometry,  PropertiesType::Pointer pProperties);
 
    SmallDisplacementBeamElement3D2N(SmallDisplacementBeamElement3D2N const& rOther);
 
    ~SmallDisplacementBeamElement3D2N() override;
 
 
 
 
    Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes,  PropertiesType::Pointer pProperties) 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:
    //************* STARTING - ENDING  METHODS
 
    void Initialize(const ProcessInfo& rCurrentProcessInfo) override;
 
    void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo) override;
 
    //************* COMPUTING  METHODS
 
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateLeftHandSide(MatrixType& rLeftHandSideMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    void CalculateMassMatrix(MatrixType& rMassMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //on integration points:
    void CalculateOnIntegrationPoints( const Variable< array_1d<double, 3 > >& rVariable,
                                       std::vector< array_1d<double, 3 > >& Output,
                                       const ProcessInfo& rCurrentProcessInfo) override;
 
 
    //************************************************************************************
    //************************************************************************************
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "Beam Element #" << Id();
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "Beam Element #" << Id();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      GetGeometry().PrintData(rOStream);
    }
 
protected:
 
 
    IntegrationMethod mThisIntegrationMethod;
 
 
    SectionProperties mSection;
 
 
    double mLength;                          // Length of the beam element
 
    SmallDisplacementBeamElement3D2N() {};
 
    //constexpr const std::size_t& Dimension() const {return GetGeometry().WorkingSpaceDimension();}
 
 
 
    void CalculateElementalSystem( LocalSystemComponents& rLocalSystem,
                   const ProcessInfo& rCurrentProcessInfo );
 
 
    void CalculateSectionProperties();
 
    virtual void InitializeSystemMatrices(MatrixType& rLeftHandSideMatrix,
                                          VectorType& rRightHandSideVector,
                                          Flags& rCalculationFlags);
 
    void CalculateAndAddLHS(LocalSystemComponents& rLocalSystem);
 
    void CalculateAndAddRHS(LocalSystemComponents& rLocalSystem, Vector& VolumeForce);
 
    void CalculateLocalStiffnessMatrix(Matrix& LocalMatrix);
 
 
    void CalculateTransformationMatrix(Matrix& RotationMatrix);
 
 
    virtual Vector& CalculateVolumeForce(Vector& rVolumeForce, const Vector& rN);
 
    void CalculateGlobalBodyForce(Vector& rGlobalForceVector, Vector& rVolumeForce);
 
 
    void CalculateLocalBodyForce(Vector& rLocalBody, Vector& rVolumeForce);
 
 
    void CalculateDistributedBodyForce(const int Direction, Vector& Load, Vector& rVolumeForce);
 
 
    double CalculateInternalAxil  ( const double& N, const double& AxialLoad, const double& X );
 
    double CalculateInternalShear ( const double& Q, const double& ShearLoad, const double& X );
 
    double CalculateInternalMoment( const double& M1, const double& M2, const double& ShearLoad, const double& X );
 
 
   void CalculateLocalNodalStress(Vector& Stress, Vector& rVolumeForce );
 
 
private:
 
    friend class Serializer;
 
 
    // A private default constructor necessary for serialization
 
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, Element )
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, Element )
    }
 
 
 
}; // Class SmallDisplacementBeamElement3D2N
 
} // namespace Kratos.
#endif //  KRATOS_SMALL_DISPLACEMENT_BEAM_ELEMENT_3D2N_H_INCLUDED defined