embedded_mls_constraint_process.h

Go to the documentation of this file.

// KRATOS ___ ___  _  ___   __   ___ ___ ___ ___
//       / __/ _ \| \| \ \ / /__|   \_ _| __| __|
//      | (_| (_) | .` |\ V /___| |) | || _|| _|
//       \___\___/|_|\_| \_/    |___/___|_| |_|  APPLICATION
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//                   Franziska Wahl
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "containers/model.h"
#include "processes/process.h"
#include "utilities/mls_shape_functions_utility.h"
 
// Application includes
 
namespace Kratos
{
 
 
 
 
 
 
class KRATOS_API(CONVECTION_DIFFUSION_APPLICATION) EmbeddedMLSConstraintProcess : public Process
{
public:
 
 
    using IndexType = ModelPart::IndexType;
 
    using NodeType = ModelPart::NodeType;
 
    using GeometryType = ModelPart::GeometryType;
 
    using MLSShapeFunctionsFunctionType = std::function<void(const Matrix&, const array_1d<double,3>&, const double, Vector&)>;
 
    using NodesCloudSetType = std::unordered_set<NodeType::Pointer, SharedPointerHasher<NodeType::Pointer>, SharedPointerComparator<NodeType::Pointer>>;
 
    using CloudDataVectorType = DenseVector<std::pair<NodeType::Pointer, double>>;
 
    using NodesCloudMapType = std::unordered_map<NodeType::Pointer, CloudDataVectorType, SharedPointerHasher<NodeType::Pointer>, SharedPointerComparator<NodeType::Pointer>>;
 
 
    KRATOS_CLASS_POINTER_DEFINITION(EmbeddedMLSConstraintProcess);
 
 
    EmbeddedMLSConstraintProcess() = delete;
 
    EmbeddedMLSConstraintProcess(
        Model& rModel,
        Parameters ThisParameters);
 
    virtual ~EmbeddedMLSConstraintProcess() = default;
 
 
 
 
    void Execute() override;
 
    const Parameters GetDefaultParameters() const override
    {
        const Parameters default_parameters = Parameters(R"({
            "model_part_name" : "",
            "unknown_variable" : "TEMPERATURE",
            "mls_extension_operator_order" : 1,
            "deactivate_negative_elements" : true,
            "deactivate_intersected_elements" : false
        })" );
 
        return default_parameters;
    }
 
 
 
 
    virtual std::string Info() const override
    {
        return "EmbeddedMLSConstraintProcess";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "EmbeddedMLSConstraintProcess";
    }
 
    virtual void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
protected:
 
 
 
 
 
 
 
 
 
private:
 
 
 
    ModelPart* mpModelPart = nullptr;
 
    std::string mUnknownVariable;
 
    std::size_t mMLSExtensionOperatorOrder;
 
    bool mDeactivateNegativeElements;
    bool mDeactivateIntersectedElements;
 
 
 
    void CalculateConformingExtensionBasis(
        NodesCloudMapType& rExtensionOperatorMap);
 
    void ApplyExtensionConstraints(
        NodesCloudMapType& rExtensionOperatorMap);
 
    void SetInterfaceFlags();
 
    void ReactivateElementsAndNodes();
 
    void ModifyDistances();
 
    bool IsSplit(const GeometryType& rGeometry);
 
    bool IsNegative(const GeometryType& rGeometry);
 
    MLSShapeFunctionsFunctionType GetMLSShapeFunctionsFunction();
 
    void SetNegativeNodeSupportCloud(
        const NodeType& rNegativeNode,
        PointerVector<NodeType>& rCloudNodes,
        Matrix& rCloudCoordinates);
 
    double CalculateKernelRadius(
        const Matrix& rCloudCoordinates,
        const array_1d<double,3>& rOrigin);
 
    std::size_t GetRequiredNumberOfPoints();
 
 
 
 
}; // Class EmbeddedMLSConstraintProcess
 
} // namespace Kratos.