element.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                     Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
 
#if !defined(KRATOS_ELEMENT_H_INCLUDED )
#define  KRATOS_ELEMENT_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/properties.h"
#include "includes/process_info.h"
#include "includes/geometrical_object.h"
#include "includes/constitutive_law.h"
#include "includes/kratos_parameters.h"
#include "containers/global_pointers_vector.h"
 
namespace Kratos
{
 
 
 
 
 
 
class Element : public GeometricalObject
{
public:
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(Element);
 
    typedef Element ElementType;
 
    typedef GeometricalObject BaseType;
 
    typedef Node NodeType;
 
    typedef Properties PropertiesType;
 
    typedef Geometry<NodeType> GeometryType;
 
    typedef Geometry<NodeType>::PointsArrayType NodesArrayType;
 
    typedef Vector VectorType;
 
    typedef Matrix MatrixType;
 
    typedef std::size_t IndexType;
 
    typedef std::size_t SizeType;
 
    typedef Dof<double> DofType;
 
    typedef std::vector<std::size_t> EquationIdVectorType;
 
    typedef std::vector<DofType::Pointer> DofsVectorType;
 
    typedef PointerVectorSet<DofType> DofsArrayType;
 
    typedef GeometryData::IntegrationMethod IntegrationMethod;
 
    typedef GeometryData GeometryDataType;
 
 
    explicit Element(IndexType NewId = 0)
        : BaseType(NewId)
        , mpProperties(nullptr)
    {
    }
 
    Element(IndexType NewId, const NodesArrayType& ThisNodes)
        : BaseType(NewId,GeometryType::Pointer(new GeometryType(ThisNodes)))
        , mpProperties(nullptr)
    {
    }
 
    Element(IndexType NewId, GeometryType::Pointer pGeometry)
        : BaseType(NewId,pGeometry)
        , mpProperties(nullptr)
    {
    }
 
    Element(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties)
        : BaseType(NewId,pGeometry)
        , mpProperties(pProperties)
    {
    }
 
 
    Element(Element const& rOther)
        : BaseType(rOther)
        , mpProperties(rOther.mpProperties)
    {
    }
 
 
    ~Element() override
    {
    }
 
 
 
    Element & operator=(Element const& rOther)
    {
        BaseType::operator=(rOther);
        mpProperties = rOther.mpProperties;
        return *this;
    }
 
 
    virtual Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes,
                           PropertiesType::Pointer pProperties) const
    {
        KRATOS_TRY
        KRATOS_ERROR << "Please implement the First Create method in your derived Element" << Info() << std::endl;
        return Kratos::make_intrusive<Element>(NewId, GetGeometry().Create(ThisNodes), pProperties);
        KRATOS_CATCH("");
    }
 
    virtual Pointer Create(IndexType NewId,
                           GeometryType::Pointer pGeom,
                           PropertiesType::Pointer pProperties) const
    {
        KRATOS_TRY
        KRATOS_ERROR << "Please implement the Second Create method in your derived Element" << Info() << std::endl;
        return Kratos::make_intrusive<Element>(NewId, pGeom, pProperties);
        KRATOS_CATCH("");
    }
 
    virtual Pointer Clone (IndexType NewId, NodesArrayType const& ThisNodes) const
    {
        KRATOS_TRY
        KRATOS_WARNING("Element") << " Call base class element Clone " << std::endl;
        Element::Pointer p_new_elem = Kratos::make_intrusive<Element>(NewId, GetGeometry().Create(ThisNodes), pGetProperties());
        p_new_elem->SetData(this->GetData());
        p_new_elem->Set(Flags(*this));
        return p_new_elem;
        KRATOS_CATCH("");
    }
 
 
    virtual void EquationIdVector(EquationIdVectorType& rResult,
                                  const ProcessInfo& rCurrentProcessInfo) const
    {
        if (rResult.size() != 0) {
            rResult.resize(0);
        }
    }
 
    virtual void GetDofList(DofsVectorType& rElementalDofList,
                            const ProcessInfo& rCurrentProcessInfo) const
    {
        if (rElementalDofList.size() != 0) {
            rElementalDofList.resize(0);
        }
    }
 
    virtual IntegrationMethod GetIntegrationMethod() const
    {
        return pGetGeometry()->GetDefaultIntegrationMethod();
    }
 
    virtual void GetValuesVector(Vector& values, int Step = 0) const
    {
        if (values.size() != 0) {
            values.resize(0, false);
        }
    }
 
    virtual void GetFirstDerivativesVector(Vector& values, int Step = 0) const
    {
        if (values.size() != 0) {
            values.resize(0, false);
        }
    }
 
    virtual void GetSecondDerivativesVector(Vector& values, int Step = 0) const
    {
        if (values.size() != 0) {
            values.resize(0, false);
        }
    }
 
    virtual void Initialize(const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void ResetConstitutiveLaw()
    {
    }
 
    virtual void InitializeSolutionStep(const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void FinalizeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void FinalizeSolutionStep(const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix,
                                      VectorType& rRightHandSideVector,
                                      const ProcessInfo& rCurrentProcessInfo)
    {
        if (rLeftHandSideMatrix.size1() != 0) {
            rLeftHandSideMatrix.resize(0, 0, false);
        }
        if (rRightHandSideVector.size() != 0) {
            rRightHandSideVector.resize(0, false);
        }
    }
 
    virtual void CalculateLeftHandSide(MatrixType& rLeftHandSideMatrix,
                                       const ProcessInfo& rCurrentProcessInfo)
    {
        if (rLeftHandSideMatrix.size1() != 0) {
            rLeftHandSideMatrix.resize(0, 0, false);
        }
    }
 
    virtual void CalculateRightHandSide(VectorType& rRightHandSideVector,
                                        const ProcessInfo& rCurrentProcessInfo)
    {
        if (rRightHandSideVector.size() != 0) {
            rRightHandSideVector.resize(0, false);
        }
    }
 
    virtual void CalculateFirstDerivativesContributions(MatrixType& rLeftHandSideMatrix,
                                                        VectorType& rRightHandSideVector,
                                                        const ProcessInfo& rCurrentProcessInfo)
    {
        if (rLeftHandSideMatrix.size1() != 0) {
            rLeftHandSideMatrix.resize(0, 0, false);
        }
        if (rRightHandSideVector.size() != 0) {
            rRightHandSideVector.resize(0, false);
        }
    }
 
    virtual void CalculateFirstDerivativesLHS(MatrixType& rLeftHandSideMatrix,
                                              const ProcessInfo& rCurrentProcessInfo)
    {
        if (rLeftHandSideMatrix.size1() != 0) {
            rLeftHandSideMatrix.resize(0, 0, false);
        }
    }
 
    virtual void CalculateFirstDerivativesRHS(VectorType& rRightHandSideVector,
                                              const ProcessInfo& rCurrentProcessInfo)
    {
        if (rRightHandSideVector.size() != 0) {
            rRightHandSideVector.resize(0, false);
        }
    }
 
    virtual void CalculateSecondDerivativesContributions(MatrixType& rLeftHandSideMatrix,
                                                         VectorType& rRightHandSideVector,
                                                         const ProcessInfo& rCurrentProcessInfo)
    {
        if (rLeftHandSideMatrix.size1() != 0) {
            rLeftHandSideMatrix.resize(0, 0, false);
        }
        if (rRightHandSideVector.size() != 0) {
            rRightHandSideVector.resize(0, false);
        }
    }
 
    virtual void CalculateSecondDerivativesLHS(MatrixType& rLeftHandSideMatrix,
                                               const ProcessInfo& rCurrentProcessInfo)
    {
        if (rLeftHandSideMatrix.size1() != 0) {
            rLeftHandSideMatrix.resize(0, 0, false);
        }
    }
 
    virtual void CalculateSecondDerivativesRHS(VectorType& rRightHandSideVector,
                                               const ProcessInfo& rCurrentProcessInfo)
    {
        if (rRightHandSideVector.size() != 0) {
            rRightHandSideVector.resize(0, false);
        }
    }
 
    virtual void CalculateMassMatrix(MatrixType& rMassMatrix, const ProcessInfo& rCurrentProcessInfo)
    {
        if (rMassMatrix.size1() != 0) {
            rMassMatrix.resize(0, 0, false);
        }
    }
 
    virtual void CalculateDampingMatrix(MatrixType& rDampingMatrix, const ProcessInfo& rCurrentProcessInfo)
    {
        if (rDampingMatrix.size1() != 0) {
            rDampingMatrix.resize(0, 0, false);
        }
    }
 
    virtual void CalculateLumpedMassVector(
        VectorType& rLumpedMassVector,
        const ProcessInfo& rCurrentProcessInfo) const
        {
            KRATOS_TRY;
            KRATOS_ERROR << "Calling the CalculateLumpedMassVector() method of the base element. The method must be implemented in the derived element.";
            KRATOS_CATCH("");
        }
 
 
    virtual void AddExplicitContribution(const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void AddExplicitContribution(
        const VectorType& rRHSVector,
        const Variable<VectorType>& rRHSVariable,
        const Variable<double >& rDestinationVariable,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
        KRATOS_ERROR << "Base element class is not able to assemble rRHS to the desired variable. destination variable is " << rDestinationVariable << std::endl;
    }
 
    virtual void AddExplicitContribution(
        const VectorType& rRHSVector,
        const Variable<VectorType>& rRHSVariable,
        const Variable<array_1d<double,3> >& rDestinationVariable,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
         KRATOS_ERROR << "Base element class is not able to assemble rRHS to the desired variable. destination variable is " << rDestinationVariable << std::endl;
    }
 
    virtual void AddExplicitContribution(
        const MatrixType& rLHSMatrix,
        const Variable<MatrixType>& rLHSVariable,
        const Variable<Matrix>& rDestinationVariable,
        const ProcessInfo& rCurrentProcessInfo
        )
    {
         KRATOS_ERROR << "Base element class is not able to assemble rLHS to the desired variable. destination variable is " << rDestinationVariable << std::endl;
    }
 
    virtual void Calculate(const Variable<double>& rVariable,
                           double& Output,
                           const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void Calculate(const Variable<array_1d<double, 3 > >& rVariable,
                           array_1d<double, 3 > & Output,
                           const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void Calculate(const Variable<Vector >& rVariable,
                           Vector& Output,
                           const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void Calculate(const Variable<Matrix >& rVariable,
                           Matrix& Output,
                           const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<bool>& rVariable,
        std::vector<bool>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<int>& rVariable,
        std::vector<int>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<double>& rVariable,
        std::vector<double>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<array_1d<double, 3>>& rVariable,
        std::vector< array_1d<double, 3>>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<array_1d<double, 4>>& rVariable,
        std::vector< array_1d<double, 4>>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<array_1d<double, 6>>& rVariable,
        std::vector<array_1d<double, 6>>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<array_1d<double, 9>>& rVariable,
        std::vector<array_1d<double, 9>>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<Vector>& rVariable,
        std::vector<Vector>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<Matrix>& rVariable,
        std::vector<Matrix>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateOnIntegrationPoints(
        const Variable<ConstitutiveLaw::Pointer>& rVariable,
        std::vector<ConstitutiveLaw::Pointer>& rOutput,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    // virtual void CalculateOnIntegrationPoints(const Variable<ConstitutiveLaw::StrainVectorType>& rVariable,
    //                       std::vector<ConstitutiveLaw::StrainVectorType>& rOutput,
    //                       const ProcessInfo& rCurrentProcessInfo)
    // {
    // }
 
    // virtual void CalculateOnIntegrationPoints(const Variable<ConstitutiveLaw::StressVectorType>& rVariable,
    //                       std::vector<ConstitutiveLaw::StressVectorType>& rOutput,
    //                       const ProcessInfo& rCurrentProcessInfo)
    // {
    // }
 
    // virtual void CalculateOnIntegrationPoints(const Variable<ConstitutiveLaw::VoigtSizeMatrixType>& rVariable,
    //                       std::vector<ConstitutiveLaw::VoigtSizeMatrixType>& rOutput,
    //                       const ProcessInfo& rCurrentProcessInfo)
    // {
    // }
 
    // virtual void CalculateOnIntegrationPoints(const Variable<ConstitutiveLaw::DeformationGradientMatrixType>& rVariable,
    //                       std::vector<ConstitutiveLaw::DeformationGradientMatrixType>& rOutput,
    //                       const ProcessInfo& rCurrentProcessInfo)
    // {
    // }
 
    //SET ON INTEGRATION POINTS - METHODS
    virtual void SetValuesOnIntegrationPoints(
        const Variable<bool>& rVariable,
        const std::vector<bool>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
    virtual void SetValuesOnIntegrationPoints(
        const Variable<int>& rVariable,
        const std::vector<int>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<double>& rVariable,
        const std::vector<double>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<array_1d<double, 3>>& rVariable,
        const std::vector<array_1d<double, 3>>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<array_1d<double, 4>>& rVariable,
        const std::vector<array_1d<double, 4>>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<array_1d<double, 6>>& rVariable,
        const std::vector<array_1d<double, 6>>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<array_1d<double, 9>>& rVariable,
        const std::vector<array_1d<double, 9>>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<Vector>& rVariable,
        const std::vector<Vector>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<Matrix>& rVariable,
        const std::vector<Matrix>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void SetValuesOnIntegrationPoints(
        const Variable<ConstitutiveLaw::Pointer>& rVariable,
        const std::vector<ConstitutiveLaw::Pointer>& rValues,
        const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual int Check(const ProcessInfo& rCurrentProcessInfo) const
    {
        KRATOS_TRY
 
        KRATOS_ERROR_IF( this->Id() < 1 ) << "Element found with Id " << this->Id() << std::endl;
 
        const double domain_size = this->GetGeometry().DomainSize();
        KRATOS_ERROR_IF( domain_size <= 0.0 ) << "Element " << this->Id() << " has non-positive size " << domain_size << std::endl;
 
        GetGeometry().Check();
 
        return 0;
 
        KRATOS_CATCH("")
    }
 
    virtual void MassMatrix(MatrixType& rMassMatrix, const ProcessInfo& rCurrentProcessInfo)
    {
        if (rMassMatrix.size1() != 0) {
            rMassMatrix.resize(0, 0, false);
        }
    }
 
    virtual void AddMassMatrix(MatrixType& rLeftHandSideMatrix,
                               double coeff, const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void DampMatrix(MatrixType& rDampMatrix, const ProcessInfo& rCurrentProcessInfo)
    {
        if (rDampMatrix.size1() != 0) {
            rDampMatrix.resize(0, 0, false);
        }
    }
 
    virtual void AddInertiaForces(VectorType& rRightHandSideVector, double coeff,
                                  const ProcessInfo& rCurrentProcessInfo)
    {
    }
 
    virtual void CalculateLocalVelocityContribution(MatrixType& rDampingMatrix,
            VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo)
    {
        if (rDampingMatrix.size1() != 0) {
            rDampingMatrix.resize(0, 0, false);
        }
    }
 
    virtual void CalculateSensitivityMatrix(const Variable<double>& rDesignVariable,
                                            Matrix& rOutput,
                                            const ProcessInfo& rCurrentProcessInfo)
    {
        if (rOutput.size1() != 0)
            rOutput.resize(0, 0, false);
    }
 
    virtual void CalculateSensitivityMatrix(const Variable<array_1d<double,3> >& rDesignVariable,
                                            Matrix& rOutput,
                                            const ProcessInfo& rCurrentProcessInfo)
    {
        if (rOutput.size1() != 0)
            rOutput.resize(0, 0, false);
    }
 
    //METHODS TO BE CLEANED: DEPRECATED end
 
 
    PropertiesType::Pointer pGetProperties()
    {
        return mpProperties;
    }
 
    const PropertiesType::Pointer pGetProperties() const
    {
        return mpProperties;
    }
 
    PropertiesType& GetProperties()
    {
        KRATOS_DEBUG_ERROR_IF(mpProperties == nullptr)
            << "Tryining to get the properties of " << Info()
            << ", which are uninitialized." << std::endl;
        return *mpProperties;
    }
 
    PropertiesType const& GetProperties() const
    {
        KRATOS_DEBUG_ERROR_IF(mpProperties == nullptr)
            << "Tryining to get the properties of " << Info()
            << ", which are uninitialized." << std::endl;
        return *mpProperties;
    }
 
    void SetProperties(PropertiesType::Pointer pProperties)
    {
        mpProperties = pProperties;
    }
 
 
    bool HasProperties() const
    {
        return mpProperties != nullptr;
    }
 
 
    virtual const Parameters GetSpecifications() const
    {
        const Parameters specifications = Parameters(R"({
            "time_integration"           : [],
            "framework"                  : "lagrangian",
            "symmetric_lhs"              : false,
            "positive_definite_lhs"      : false,
            "output"                     : {
                "gauss_point"            : [],
                "nodal_historical"       : [],
                "nodal_non_historical"   : [],
                "entity"                 : []
            },
            "required_variables"         : [],
            "required_dofs"              : [],
            "flags_used"                 : [],
            "compatible_geometries"      : [],
            "element_integrates_in_time" : true,
            "compatible_constitutive_laws": {
                "type"        : [],
                "dimension"   : [],
                "strain_size" : []
            },
            "required_polynomial_degree_of_geometry" : -1,
            "documentation"   : "This is the base element"
 
        })");
        return specifications;
    }
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "Element #" << Id();
        return buffer.str();
    }
 
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "Element #" << Id();
    }
 
 
    void PrintData(std::ostream& rOStream) const override
    {
        pGetGeometry()->PrintData(rOStream);
    }
 
 
protected:
 
private:
 
    Properties::Pointer mpProperties;
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, GeometricalObject );
        rSerializer.save("Properties", mpProperties);
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, GeometricalObject );
        rSerializer.load("Properties", mpProperties);
    }
 
 
}; // Class Element
 
 
inline std::istream & operator >>(std::istream& rIStream,
                                  Element& rThis);
 
 
inline std::ostream & operator <<(std::ostream& rOStream,
                                  const Element& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << " : " << std::endl;
    rThis.PrintData(rOStream);
    return rOStream;
}
 
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Element >;
 
void KRATOS_API(KRATOS_CORE) AddKratosComponent(std::string const& Name, Element const& ThisComponent);
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_API
 
KRATOS_DEFINE_VARIABLE(GlobalPointersVector< Element >, NEIGHBOUR_ELEMENTS)
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_NO_EXPORT
 
} // namespace Kratos.
#endif // KRATOS_ELEMENT_H_INCLUDED  defined