thermal_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_THERMAL_ELEMENT_H_INCLUDED )
#define  KRATOS_THERMAL_ELEMENT_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/checks.h"
#include "includes/element.h"
#include "custom_utilities/element_utilities.hpp"
 
namespace Kratos
{
 
class KRATOS_API(SOLID_MECHANICS_APPLICATION) ThermalElement
    : public Element
{
 public:
 
  typedef ConstitutiveLaw ConstitutiveLawType;
  typedef ConstitutiveLawType::Pointer ConstitutiveLawPointerType;
  typedef ConstitutiveLawType::StressMeasure StressMeasureType;
  typedef GeometryData::IntegrationMethod IntegrationMethod;
 
 
  KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(ThermalElement);
 
 
 protected:
 
  KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_RHS_VECTOR );
  KRATOS_DEFINE_LOCAL_FLAG( COMPUTE_LHS_MATRIX );
 
  struct GeneralVariables
  {
 
    //for axisymmetric use only
    double  CurrentRadius;
    double  ReferenceRadius;
 
    //general thermal variables
    double  DeltaTime;
    double  HeatCapacity;
    double  HeatConductivity;
    double  PlasticDissipation;
    double  DeltaPlasticDissipation;
 
    //general mechanical variables
    double  detJ;
    Vector  N;
    Matrix  DN_DX;
 
    //variables including all integration points
    const GeometryType::ShapeFunctionsGradientsType* pDN_De;
    GeometryType::JacobiansType J;
    GeometryType::JacobiansType j;
    const Matrix* pNcontainer;
    Matrix  DeltaPosition;
 
    void SetShapeFunctionsGradients(const GeometryType::ShapeFunctionsGradientsType &rDN_De)
    {
      pDN_De=&rDN_De;
    };
 
    void SetShapeFunctions(const Matrix& rNcontainer)
    {
      pNcontainer=&rNcontainer;
    };
 
 
    const GeometryType::ShapeFunctionsGradientsType& GetShapeFunctionsGradients()
    {
      return *pDN_De;
    };
 
    const Matrix& GetShapeFunctions()
    {
      return *pNcontainer;
    };
 
 
  };
 
 
 public:
 
 
 
  ThermalElement(IndexType NewId, GeometryType::Pointer pGeometry);
  ThermalElement(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
  ThermalElement(ThermalElement const& rOther);
 
 
  ~ThermalElement() override;
 
 
  ThermalElement& operator=(ThermalElement const& rOther);
 
 
 
  Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes, PropertiesType::Pointer pProperties) const override;
 
  //Element::Pointer Clone(IndexType NewId, NodesArrayType const& ThisNodes) const;
 
 
  //************* 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:
  //SET
  void SetValuesOnIntegrationPoints(const Variable<double>& rVariable, const std::vector<double>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
  void SetValuesOnIntegrationPoints(const Variable<Vector>& rVariable, const std::vector<Vector>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
  void SetValuesOnIntegrationPoints(const Variable<Matrix>& rVariable, const std::vector<Matrix>& rValues, const ProcessInfo& rCurrentProcessInfo) override;
 
 
  //************* 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;
 
  void CalculateDampingMatrix(MatrixType& rDampingMatrix, const ProcessInfo& rCurrentProcessInfo) override;
 
 
  //on integration points:
  void CalculateOnIntegrationPoints(const Variable<double>& rVariable, std::vector<double>& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
  void CalculateOnIntegrationPoints(const Variable<Vector>& rVariable, std::vector<Vector>& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
  void CalculateOnIntegrationPoints(const Variable<Matrix >& rVariable, std::vector< Matrix >& rOutput, const ProcessInfo& rCurrentProcessInfo) override;
 
 
  //************************************************************************************
  //************************************************************************************
  int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
  //std::string Info() const;
 
 
 
  //      virtual String Info() const;
 
  //      virtual void PrintInfo(std::ostream& rOStream) const;
 
  //      virtual void PrintData(std::ostream& rOStream) const;
 
 protected:
 
  IntegrationMethod mThisIntegrationMethod;
 
  ThermalElement() : Element()
  {
  }
 
  virtual void CalculateElementalSystem(MatrixType& rLeftHandSideMatrix,
                                        VectorType& rRightHandSideVector,
                                        const ProcessInfo& rCurrentProcessInfo,
                                        Flags & rCalculationFlags);
 
 
  virtual void CalculateAndAddLHS(MatrixType& rLeftHandSideMatrix,
                                  GeneralVariables& rVariables,
                                  double& rIntegrationWeight);
 
  virtual void CalculateAndAddRHS(VectorType& rRightHandSideVector,
                                  GeneralVariables& rVariables,
                                  double& rHeatSource,
                                  double& rIntegrationWeight);
 
 
 
  virtual void CalculateAndAddKthermal(MatrixType& rK,
                                       GeneralVariables & rVariables,
                                       double& rIntegrationWeight
                                       );
 
  virtual void CalculateAndAddHthermal(MatrixType& rK,
                                       GeneralVariables & rVariables,
                                       double& rIntegrationWeight
                                       );
 
 
  virtual void CalculateAndAddMthermal(MatrixType& rM,
                                       GeneralVariables & rVariables,
                                       double& rIntegrationWeight
                                       );
 
 
  virtual void CalculateAndAddExternalForces(GeneralVariables& rVariables,
                                             VectorType& rRightHandSideVector,
                                             double& rHeatSource,
                                             double& rIntegrationWeight
                                             );
 
 
  virtual void CalculateAndAddThermalForces(GeneralVariables & rVariables,
                                            VectorType& rRightHandSideVector,
                                            double& rIntegrationWeight
                                            );
 
 
  virtual void InitializeSystemMatrices(MatrixType& rLeftHandSideMatrix,
                                        VectorType& rRightHandSideVector,
                                        Flags& rCalculationFlags);
 
  void InitializeVariables ();
 
  virtual void CalculateKinematics(GeneralVariables& rVariables,
                                   const double& rPointNumber);
 
 
  void CalculateThermalProperties(GeneralVariables& rVariables);
 
 
 
  virtual double& CalculateIntegrationWeight(double & rIntegrationWeight);
 
 
  virtual void InitializeGeneralVariables(GeneralVariables & rVariables, const ProcessInfo& rCurrentProcessInfo);
 
 
 
 
 private:
 
 
 
 
 
 
 
 
  friend class Serializer;
 
  void save(Serializer& rSerializer) const override;
 
  void load(Serializer& rSerializer) override;
 
 
}; // Class ThermalElement
 
 
} // namespace Kratos.
#endif // KRATOS_THERMAL_ELEMENT_H_INCLUDED  defined