thermal_face.h

Go to the documentation of this file.

// KRATOS ___ ___  _  ___   __   ___ ___ ___ ___
//       / __/ _ \| \| \ \ / /__|   \_ _| __| __|
//      | (_| (_) | .` |\ V /___| |) | || _|| _|
//       \___\___/|_|\_| \_/    |___/___|_| |_|  APPLICATION
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Jordi Cotela
//                   Riccardo Rossi
//                   Ruben Zorrilla
//
 
#if !defined(KRATOS_THERMAL_FACE_H_INCLUDED )
#define  KRATOS_THERMAL_FACE_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/node.h"
#include "includes/process_info.h"
#include "includes/properties.h"
#include "includes/condition.h"
#include "geometries/geometry.h"
#include "includes/variables.h"
 
namespace Kratos
{
 
 
 
class KRATOS_API(CONVECTION_DIFFUSION_APPLICATION) ThermalFace: public Condition
{
public:
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(ThermalFace);
 
    struct ConditionDataStruct
    {
        double Weight;              // Gauss point weight
        array_1d<double, 3> Normal; // Condition normal
        Vector N;                   // Gauss point shape functions values
 
        double Emissivity;            // Ambient emissivity value
        double AmbientTemperature;    // Ambient temperature value
        double ConvectionCoefficient; // Ambient convection coefficient
        Vector UnknownValues;         // Previous iteration unknown values
        Vector FaceHeatFluxValues;    // Nodal face heat flux values
 
        double inline GaussPointUnknown() const
        {
            return InterpolateInGaussPoint(UnknownValues);
        }
 
        double inline GaussPointFaceHeatFlux() const
        {
            return InterpolateInGaussPoint(FaceHeatFluxValues);
        }
 
        double inline InterpolateInGaussPoint(const Vector &rNodalValues) const
        {
            double gauss_pt_val = 0.0;
            for (unsigned int i = 0; i < N.size(); ++i) {
                gauss_pt_val += N[i] * rNodalValues[i];
            }
            return gauss_pt_val;
        }
    };
 
    typedef Condition::MatrixType MatrixType;
    typedef Condition::VectorType VectorType;
 
    constexpr static double StefanBoltzmann = 5.67e-8;
 
 
    ThermalFace(
        IndexType NewId,
        Geometry< Node >::Pointer pGeometry);
 
    ThermalFace(
        IndexType NewId,
        Geometry< Node >::Pointer pGeometry,
        Properties::Pointer pProperties);
 
    ~ThermalFace() override;
 
 
    Condition::Pointer Create(
        IndexType NewId,
        NodesArrayType const& ThisNodes,
        Properties::Pointer pProperties) const override;
 
    Condition::Pointer Create(
        IndexType NewId,
        GeometryType::Pointer pGeom,
        Properties::Pointer pProperties) const override;
 
    void CalculateLocalSystem(
        MatrixType& rLeftHandSideMatrix,
        VectorType& rRightHandSideVector,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateLeftHandSide(
        MatrixType& rLeftHandSideMatrix,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(
        VectorType& rRightHandSideVector,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void EquationIdVector(
        EquationIdVectorType& rResult,
        const ProcessInfo& rCurrentProcessInfo) const override;
 
    void GetDofList(
        DofsVectorType& ConditionalDofList,
        const ProcessInfo& CurrentProcessInfo) const override;
 
    GeometryData::IntegrationMethod GetIntegrationMethod() const override;
 
    void CalculateOnIntegrationPoints(
        const Variable<array_1d<double, 3 > >& rVariable,
        std::vector<array_1d<double, 3 > >& rValues,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        const Variable<double>& rVariable,
        std::vector<double>& rValues,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        const Variable<array_1d<double, 6 > >& rVariable,
        std::vector<array_1d<double, 6 > >& rValues,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        const Variable<Vector>& rVariable,
        std::vector<Vector>& rValues,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        const Variable<Matrix>& rVariable,
        std::vector<Matrix>& rValues,
        const ProcessInfo& rCurrentProcessInfo) override;
 
 
    std::string Info() const override;
 
    void PrintInfo(std::ostream& rOStream) const override;
 
    void PrintData(std::ostream& rOStream) const override;
 
 
protected:
 
 
    // Internal default constructor for serialization
    ThermalFace();
 
 
    virtual void SetIntegrationWeight(
        const IndexType IntegrationPointIndex,
        const typename GeometryType::IntegrationPointsArrayType& rIntegrationPoints,
        const Vector& rJacobianDeterminantsVector,
        ConditionDataStruct& rData);
 
    void AddIntegrationPointRHSContribution(
        VectorType& rRightHandSideVector,
        const ConditionDataStruct &rData);
 
    void AddIntegrationPointLHSContribution(
        MatrixType& rLeftHandSideMatrix,
        const ConditionDataStruct &rData);
 
    void FillConditionDataStructure(
        const ProcessInfo &rCurrentProcessInfo,
        ConditionDataStruct &rData);
 
 
private:
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
    ThermalFace& operator=(ThermalFace const& rOther);
 
    ThermalFace(ThermalFace const& rOther);
 
 
}; // Class ThermalFace
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_THERMAL_FACE_H_INCLUDED  defined