thermal_rankine_yield_surface.h

Go to the documentation of this file.

// KRATOS ___                _   _ _         _   _             __                       _
//       / __\___  _ __  ___| |_(_) |_ _   _| |_(_)_   _____  / /  __ ___      _____   /_\  _ __  _ __
//      / /  / _ \| '_ \/ __| __| | __| | | | __| \ \ / / _ \/ /  / _` \ \ /\ / / __| //_\\| '_ \| '_  |
//     / /__| (_) | | | \__ \ |_| | |_| |_| | |_| |\ V /  __/ /__| (_| |\ V  V /\__ \/  _  \ |_) | |_) |
//     \____/\___/|_| |_|___/\__|_|\__|\__,_|\__|_| \_/ \___\____/\__,_| \_/\_/ |___/\_/ \_/ .__/| .__/
//
//  License:         BSD License
//                   license: structural_mechanics_application/license.txt
//
//  Main authors:    Alejandro Cornejo
//
 
#pragma once
 
// System includes
 
// Project includes
#include "custom_constitutive/auxiliary_files/yield_surfaces/rankine_yield_surface.h"
#include "thermal_von_mises_yield_surface.h"
 
 
namespace Kratos
{
 
 
 
 
 
template <class TPlasticPotentialType>
class ThermalRankineYieldSurface
{
public:
 
    using PlasticPotentialType = TPlasticPotentialType;
 
    using BaseType = RankineYieldSurface<TPlasticPotentialType>;
    using ThermalVonMisesType = ThermalVonMisesYieldSurface<TPlasticPotentialType>;
 
    static constexpr SizeType Dimension = PlasticPotentialType::Dimension;
 
    static constexpr SizeType VoigtSize = PlasticPotentialType::VoigtSize;
 
    KRATOS_CLASS_POINTER_DEFINITION(ThermalRankineYieldSurface);
 
    static constexpr double tolerance = std::numeric_limits<double>::epsilon();
 
 
    ThermalRankineYieldSurface()
    {
    }
 
    ThermalRankineYieldSurface(ThermalRankineYieldSurface const &rOther)
    {
    }
 
    ThermalRankineYieldSurface &operator=(ThermalRankineYieldSurface const &rOther)
    {
        return *this;
    }
 
    virtual ~ThermalRankineYieldSurface(){};
 
 
    static void CalculateEquivalentStress(
        const array_1d<double, VoigtSize>& rStressVector,
        const Vector& rStrainVector,
        double& rEquivalentStress,
        ConstitutiveLaw::Parameters& rValues
        )
    {
        BaseType::CalculateEquivalentStress(rStressVector, rStrainVector, rEquivalentStress, rValues);
    }
 
    static void GetInitialUniaxialThreshold(ConstitutiveLaw::Parameters& rValues, double& rThreshold)
    {
        ThermalVonMisesType::GetInitialUniaxialThreshold(rValues, rThreshold);
    }
 
    static void CalculateDamageParameter(
        ConstitutiveLaw::Parameters& rValues,
        double& rAParameter,
        const double CharacteristicLength)
    {
        ThermalVonMisesType::CalculateDamageParameter(rValues, rAParameter, CharacteristicLength);
    }
 
    static void CalculatePlasticPotentialDerivative(
        const array_1d<double, VoigtSize>& rStressVector,
        const array_1d<double, VoigtSize>& rDeviator,
        const double J2,
        array_1d<double, VoigtSize>& rPlasticPotential,
        ConstitutiveLaw::Parameters& rValues
        )
    {
        BaseType::CalculatePlasticPotentialDerivative(rStressVector, rDeviator, J2, rPlasticPotential, rValues);
    }
 
    static void CalculateYieldSurfaceDerivative(
        const array_1d<double, VoigtSize>& rStressVector,
        const array_1d<double, VoigtSize>& rDeviator,
        const double J2,
        array_1d<double, VoigtSize>& rFFlux,
        ConstitutiveLaw::Parameters& rValues
        )
    {
        BaseType::CalculateYieldSurfaceDerivative(rStressVector, rDeviator, J2, rFFlux, rValues);
    }
 
    static int Check(const Properties& rMaterialProperties)
    {
        return BaseType::Check(rMaterialProperties);
    }
 
    static bool IsWorkingWithTensionThreshold()
    {
        return BaseType::IsWorkingWithTensionThreshold();
    }
 
    static double GetScaleFactorTension(const Properties& rMaterialProperties)
    {
        return BaseType::GetScaleFactorTension(rMaterialProperties);
    }
 
 
 
 
 
 
protected:
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
}; // Class RankineYieldSurface
 
 
 
 
 
} // namespace Kratos.