text: // KRATOS  ___|  |                   |                   |
  //       \___ \  __|  __| |   |  __| __| |   |  __| _` | |
  //             | |   |    |   | (    |   |   | |   (   | |
  //       _____/ \__|_|   \__,_|\___|\__|\__,_|_|  \__,_|_| MECHANICS
  //
  //  License:		 BSD License
  //					 license: structural_mechanics_application/license.txt
  //
  //  Main authors:    Vicente Mataix Ferrandiz
  //
  
  #if !defined(KRATOS_AXISYM_UPDATED_LAGRANGIAN_H_INCLUDED )
  #define  KRATOS_AXISYM_UPDATED_LAGRANGIAN_H_INCLUDED
  
  // System includes
  
  // External includes
  
  // Project includes
  #include "custom_elements/updated_lagrangian.h"
  
  namespace Kratos
  {
  ///@name Kratos Globals
  ///@{
  ///@}
  ///@name Type Definitions
  ///@{
  ///@}
  ///@name  Enum's
  ///@{
  
  ///@}
  ///@name  Functions
  ///@{
  
  ///@}
  ///@name Kratos Classes
  ///@{
  
  /// Axisymmetric Updated Lagrangian element
  
  /**
   * Implements a Axisymmetric Total Lagrangian definition for structural analysis.
   */
  
  class AxisymUpdatedLagrangian
      : public UpdatedLagrangian
  {
  public:
      ///@name Type Definitions
      ///@{
      ///Reference type definition for constitutive laws
      typedef ConstitutiveLaw ConstitutiveLawType;
  
      ///Pointer type for constitutive laws
      typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
  
      ///Type definition for integration methods
      typedef GeometryData::IntegrationMethod IntegrationMethod;
  
      /// The definition of the index type
      typedef std::size_t IndexType;
  
      /// The definition of the sizetype
      typedef std::size_t SizeType;
  
      /// Counted pointer of AxisymUpdatedLagrangian
      KRATOS_CLASS_POINTER_DEFINITION(AxisymUpdatedLagrangian);
  
      ///@}
      ///@name Life Cycle
      ///@{
  
      /// Default constructor.
      AxisymUpdatedLagrangian(IndexType NewId, GeometryType::Pointer pGeometry);
      AxisymUpdatedLagrangian(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
  
      /// Destructor.
      ~AxisymUpdatedLagrangian() override;
  
      ///@}
      ///@name Operators
      ///@{
      ///@}
      ///@name Operations
      ///@{
      /**
       * @brief Creates a new element
       * @param NewId The Id of the new created element
       * @param pGeom The pointer to the geometry of the element
       * @param pProperties The pointer to property
       * @return The pointer to the created element
       */
      Element::Pointer Create(
          IndexType NewId,
          GeometryType::Pointer pGeom,
          PropertiesType::Pointer pProperties
          ) const override;
  
      /**
       * @brief Creates a new element
       * @param NewId The Id of the new created element
       * @param ThisNodes The array containing nodes
       * @param pProperties The pointer to property
       * @return The pointer to the created element
       */
      Element::Pointer Create(
          IndexType NewId,
          NodesArrayType const& ThisNodes,
          PropertiesType::Pointer pProperties
          ) const override;
  
      //std::string Info() const;
  
      ///@}
      ///@name Access
      ///@{
  
      ///@}
      ///@name Inquiry
      ///@{
      ///@}
      ///@name Input and output
      ///@{
  
      /// Turn back information as a string.
      //      virtual String Info() const;
  
      /// Print information about this object.
      //      virtual void PrintInfo(std::ostream& rOStream) const;
  
      /// Print object's data.
      //      virtual void PrintData(std::ostream& rOStream) const;
      ///@}
      ///@name Friends
      ///@{
      ///@}
  
  protected:
      ///@name Protected static Member Variables
      ///@{
      ///@}
      ///@name Protected member Variables
      ///@{
  
      ///@}
      ///@name Protected Operators
      ///@{
  
      AxisymUpdatedLagrangian() : UpdatedLagrangian()
      {
      }
  
      ///@}
      ///@name Protected Operations
      ///@{
      ///@}
      ///@name Protected  Access
      ///@{
      ///@}
      ///@name Protected Inquiry
      ///@{
      ///@}
      ///@name Protected LifeCycle
      ///@{
      ///@}
  
  private:
      ///@name Static Member Variables
      ///@{
  
      ///@}
      ///@name Member Variables
      ///@{
  
      ///@}
      ///@name Private Operators
      ///@{
  
      ///@}
      ///@name Private Operations
      ///@{
  
      /**
       * This functions computes the integration weight to consider
       * @param IntegrationPoints: The array containing the integration points
       * @param PointNumber: The id of the integration point considered
       * @param detJ: The determinant of the jacobian of the element
       */
      double GetIntegrationWeight(
          const GeometryType::IntegrationPointsArrayType& IntegrationPoints,
          const IndexType PointNumber,
          const double detJ
          ) const override;
  
      ///@}
      ///@name Private  Access
      ///@{
      ///@}
  
      ///@}
      ///@name Serialization
      ///@{
  
      friend class Serializer;
  
      // A private default constructor necessary for serialization
  
      void save(Serializer& rSerializer) const override;
  
      void load(Serializer& rSerializer) override;
  
      ///@name Private Inquiry
      ///@{
      ///@}
      ///@name Un accessible methods
      ///@{
      /// Assignment operator.
      //AxisymUpdatedLagrangian& operator=(const AxisymUpdatedLagrangian& rOther);
      /// Copy constructor.
      //AxisymUpdatedLagrangian(const AxisymUpdatedLagrangian& rOther);
      ///@}
  
  }; // Class AxisymUpdatedLagrangian
  
  ///@}
  ///@name Type Definitions
  ///@{
  ///@}
  ///@name Input and output
  ///@{
  ///@}
  
  } // namespace Kratos.
  #endif // KRATOS_AXISYM_UPDATED_LAGRANGIAN_H_INCLUDED  defined
  