fluid_auxiliary_utilities.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//                   Suneth Warnakulasuriya
//
 
#if !defined(KRATOS_FLUID_AUXILIARY_UTILITIES_H)
#define KRATOS_FLUID_AUXILIARY_UTILITIES_H
 
// System includes
 
// External includes
 
// Project includes
#include "geometries/geometry.h"
#include "includes/node.h"
#include "includes/model_part.h"
#include "includes/ublas_interface.h"
#include "modified_shape_functions/modified_shape_functions.h"
 
// Application includes
 
 
namespace Kratos
{
 
 
class KRATOS_API(FLUID_DYNAMICS_APPLICATION) FluidAuxiliaryUtilities
{
public:
 
    using IndexType = std::size_t;
 
    using NodeType = Node;
 
    using GeometryType = Geometry<NodeType>;
 
    using ModifiedShapeFunctionsFactoryType = std::function<ModifiedShapeFunctions::UniquePointer(const GeometryType::Pointer, const Vector&)>;
 
 
    static inline bool IsSplit(const Vector& rElementDistancesVector)
    {
        std::size_t n_pos(0);
        std::size_t n_neg(0);
        const std::size_t pts_number = rElementDistancesVector.size();
        for (std::size_t i_node = 0; i_node < pts_number; ++i_node){
            if (rElementDistancesVector[i_node] > 0.0)
                n_pos++;
            else
                n_neg++;
        }
        return (n_pos > 0 && n_neg > 0) ? true : false;
    }
 
    static inline bool IsPositive(const Vector &rElementDistancesVector)
    {
        std::size_t n_pos (0);
        const std::size_t pts_number = rElementDistancesVector.size();
        for (std::size_t i_node = 0; i_node < pts_number; ++i_node){
            if (rElementDistancesVector[i_node] > 0.0)
                n_pos++;
        }
        return (n_pos == pts_number) ? true : false;
    }
 
    static inline bool IsNegative(const Vector &rElementDistancesVector)
    {
        std::size_t n_neg (0);
        const std::size_t pts_number = rElementDistancesVector.size();
        for (std::size_t i_node = 0; i_node < pts_number; ++i_node){
            if (rElementDistancesVector[i_node] < 0.0)
                n_neg++;
        }
        return n_neg == pts_number;
    }
 
    static double CalculateFluidVolume(const ModelPart& rModelPart);
 
    static double CalculateFluidPositiveVolume(const ModelPart& rModelPart);
 
    static double CalculateFluidNegativeVolume(const ModelPart& rModelPart);
 
    static double CalculateFlowRate(const ModelPart& rModelPart);
 
    static double CalculateFlowRatePositiveSkin(const ModelPart& rModelPart);
 
    static double CalculateFlowRateNegativeSkin(const ModelPart& rModelPart);
 
    static double CalculateFlowRatePositiveSkin(
        const ModelPart& rModelPart,
        const Flags& rSkinFlag);
 
    static double CalculateFlowRateNegativeSkin(
        const ModelPart& rModelPart,
        const Flags& rSkinFlag);
 
    static ModifiedShapeFunctionsFactoryType GetStandardModifiedShapeFunctionsFactory(const GeometryType& rGeometry);
 
    static void MapVelocityFromSkinToVolumeRBF(
        ModelPart& rVolumeModelPart,
        ModelPart& rSkinModelPart,
        const double SearchRadius);
 
    static double FindMaximumEdgeLength(
        ModelPart& rModelPart,
        const bool CalculateNodalNeighbours = true);
 
private:
 
    static double CalculateConditionFlowRate(const GeometryType& rGeometry);
 
    template<bool IsPositiveSubdomain, bool CheckConditionFlag>
    static double CalculateFlowRateAuxiliary(
        const ModelPart& rModelPart,
        const Flags& rSkinFlag = Flags());
 
    template<bool CheckConditionFlag>
    static bool CheckConditionFlagAuxiliary(
        const Condition& rCondition,
        const Flags& rSkinFlag);
 
    template<bool IsPositiveSubdomain>
    static inline bool CheckNonSplitConditionSubdomain(const Vector &rElementDistancesVector);
 
    template<bool IsPositiveSubdomain>
    static void CalculateSplitConditionGeometryData(
        const ModifiedShapeFunctions::UniquePointer& rpModShapeFunc,
        const std::size_t FaceId,
        Matrix& rShapeFunctions,
        std::vector<array_1d<double,3>>& rNormals,
        Vector& rWeights);
 
};
 
 
} // namespace Kratos
 
#endif // KRATOS_FLUID_AUXILIARY_UTILITIES_H