metrics_hessian_process.h

Go to the documentation of this file.

// KRATOS  __  __ _____ ____  _   _ ___ _   _  ____
//        |  \/  | ____/ ___|| | | |_ _| \ | |/ ___|
//        | |\/| |  _| \___ \| |_| || ||  \| | |  _
//        | |  | | |___ ___) |  _  || || |\  | |_| |
//        |_|  |_|_____|____/|_| |_|___|_| \_|\____| APPLICATION
//
//  License:         BSD License
//                       license: MeshingApplication/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_HESSIAN_METRICS_PROCESS)
#define KRATOS_HESSIAN_METRICS_PROCESS
 
// Project includes
#include "meshing_application_variables.h"
#include "processes/process.h"
#include "includes/kratos_parameters.h"
#include "includes/model_part.h"
 
namespace Kratos
{
 
 
    typedef std::size_t SizeType;
 
 
 
 
    struct AuxiliarHessianComputationVariables
    {
        AuxiliarHessianComputationVariables(
            const double AnisotropicRatio,
            const double ElementMinSize,
            const double ElementMaxSize,
            const double NodalH,
            const bool EstimateInterpolationError,
            const double InterpolationError,
            const double MeshDependentConstant,
            const bool AnisotropyRemeshing,
            const bool EnforceAnisotropyRelativeVariable
        ) : mAnisotropicRatio(AnisotropicRatio),
            mElementMinSize(ElementMinSize),
            mElementMaxSize(ElementMaxSize),
            mNodalH(NodalH),
            mEstimateInterpolationError(EstimateInterpolationError),
            mInterpolationError(InterpolationError),
            mMeshDependentConstant(MeshDependentConstant),
            mAnisotropyRemeshing(AnisotropyRemeshing),
            mEnforceAnisotropyRelativeVariable(EnforceAnisotropyRelativeVariable)
        {
 
        };
 
        double mAnisotropicRatio;                
        double mElementMinSize;                  
        double mElementMaxSize;                  
        double mNodalH;                          
        const bool mEstimateInterpolationError;        
        const double mInterpolationError;              
        const double mMeshDependentConstant;           
        const bool mAnisotropyRemeshing;               
        const bool mEnforceAnisotropyRelativeVariable; 
    };
 
class KRATOS_API(MESHING_APPLICATION) ComputeHessianSolMetricProcess
    : public Process
{
public:
 
 
    typedef Node                                                                NodeType;
 
    typedef ModelPart::NodesContainerType                                     NodesArrayType;
    typedef ModelPart::ElementsContainerType                               ElementsArrayType;
    typedef ModelPart::ConditionsContainerType                           ConditionsArrayType;
 
    typedef std::size_t                                                            IndexType;
 
    KRATOS_CLASS_POINTER_DEFINITION(ComputeHessianSolMetricProcess);
 
 
    enum class Interpolation {CONSTANT = 0, LINEAR = 1, EXPONENTIAL = 2};
 
    enum class Normalization {CONSTANT = 0, VALUE = 1, NORM_GRADIENT = 2};
 
 
    // Constructor
 
    ComputeHessianSolMetricProcess(
        ModelPart& rThisModelPart,
        Parameters ThisParameters = Parameters(R"({})")
        );
 
    ComputeHessianSolMetricProcess(
        ModelPart& rThisModelPart,
        Variable<double>& rVariable,
        Parameters ThisParameters = Parameters(R"({})")
        );
 
    ~ComputeHessianSolMetricProcess() override = default;
 
 
    void operator()()
    {
        Execute();
    }
 
 
    void Execute() override;
 
    const Parameters GetDefaultParameters() const override;
 
 
 
 
 
 
    std::string Info() const override
    {
        return "ComputeHessianSolMetricProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "ComputeHessianSolMetricProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
    ModelPart& mrModelPart;                                           
 
    bool mNonHistoricalVariable = false;                              
    const Variable<double>* mpOriginVariable;                         
    const Variable<double>* mpRatioReferenceVariable;                 
 
    Parameters mThisParameters;                                       
    Interpolation mInterpolation;                                     
 
 
 
    template<SizeType TDim>
    static array_1d<double, 3 * (TDim - 1)> ComputeHessianMetricTensor(
        const Vector& rHessian,
        const AuxiliarHessianComputationVariables& rAuxiliarHessianComputationVariables
        );
 
    void CalculateAuxiliarHessian();
 
    Interpolation ConvertInter(const std::string& Str)
    {
        if(Str == "Constant" || Str == "CONSTANT" || Str == "constant")
            return Interpolation::CONSTANT;
        else if(Str == "Linear" || Str == "LINEAR"  || Str == "linear")
            return Interpolation::LINEAR;
        else if(Str == "Exponential" || Str == "EXPONENTIAL"  || Str == "exponential")
            return Interpolation::EXPONENTIAL;
        else
            return Interpolation::LINEAR;
    }
 
    Normalization ConvertNormalization(const std::string& Str)
    {
        if(Str == "Constant" || Str == "CONSTANT" || Str == "constant")
            return Normalization::CONSTANT;
        else if(Str == "Value" || Str == "VALUE" || Str == "value")
            return Normalization::VALUE;
        else if(Str == "Norm_Gradient" || Str == "NORM_GRADIENT" || Str == "norm_gradient")
            return Normalization::NORM_GRADIENT;
        else
            return Normalization::CONSTANT;
    }
 
    static double CalculateAnisotropicRatio(
        const double Distance,
        const double AnisotropicRatio,
        const double BoundLayer,
        const Interpolation rInterpolation
        );
 
    template<SizeType TDim>
    void CalculateMetric();
 
    void InitializeVariables(Parameters ThisParameters);
 
 
 
 
 
    ComputeHessianSolMetricProcess& operator=(ComputeHessianSolMetricProcess const& rOther);
 
    //ComputeHessianSolMetricProcess(ComputeHessianSolMetricProcess const& rOther);
 
};// class ComputeHessianSolMetricProcess
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  ComputeHessianSolMetricProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const ComputeHessianSolMetricProcess& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
};// namespace Kratos.
#endif /* KRATOS_HESSIAN_METRICS_PROCESS defined */