embedded_discontinuous_data.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//
 
#if !defined(KRATOS_EMBEDDED_DISCONTINUOUS_DATA_H)
#define KRATOS_EMBEDDED_DISCONTINUOUS_DATA_H
 
#include "fluid_dynamics_application_variables.h"
#include "custom_utilities/fluid_element_data.h"
 
namespace Kratos {
 
 
 
template< class TFluidData >
class EmbeddedDiscontinuousData : public TFluidData
{
public:
 
 
using NodalScalarData = typename TFluidData::NodalScalarData;
using NodalVectorData = typename TFluidData::NodalVectorData;
 
typedef GeometryData::ShapeFunctionsGradientsType ShapeFunctionsGradientsType;
typedef std::vector<array_1d<double,3>> InterfaceNormalsType;
 
constexpr static std::size_t NumEdges = (TFluidData::NumNodes == 3) ? 3 : 6;
 
 
double SlipLength;
double PenaltyCoefficient;
 
NodalScalarData ElementalDistances;
Vector ElementalEdgeDistancesExtrapolated;
 
Matrix PositiveSideN;
Matrix NegativeSideN;
ShapeFunctionsGradientsType PositiveSideDNDX;
ShapeFunctionsGradientsType NegativeSideDNDX;
Vector PositiveSideWeights;
Vector NegativeSideWeights;
 
Matrix PositiveInterfaceN;
Matrix NegativeInterfaceN;
ShapeFunctionsGradientsType PositiveInterfaceDNDX;
ShapeFunctionsGradientsType NegativeInterfaceDNDX;
Vector PositiveInterfaceWeights;
Vector NegativeInterfaceWeights;
InterfaceNormalsType PositiveInterfaceUnitNormals;
InterfaceNormalsType NegativeInterfaceUnitNormals;
 
std::vector< size_t > PositiveIndices;
std::vector< size_t > NegativeIndices;
 
std::size_t NumPositiveNodes;
std::size_t NumNegativeNodes;
std::size_t NumIntersectedEdgesExtrapolated;
 
 
void Initialize(
    const Element& rElement,
    const ProcessInfo& rProcessInfo) override
{
    TFluidData::Initialize(rElement, rProcessInfo);
    this->FillFromElementData(ElementalDistances, ELEMENTAL_DISTANCES, rElement);
    this->FillFromElementData(ElementalEdgeDistancesExtrapolated, ELEMENTAL_EDGE_DISTANCES_EXTRAPOLATED, rElement);
 
    NumPositiveNodes = 0;
    NumNegativeNodes = 0;
    NumIntersectedEdgesExtrapolated = 0;
}
 
void InitializeBoundaryConditionData(const ProcessInfo& rProcessInfo)
{
    this->FillFromProcessInfo(SlipLength, SLIP_LENGTH, rProcessInfo);
    this->FillFromProcessInfo(PenaltyCoefficient, PENALTY_COEFFICIENT, rProcessInfo);
}
 
static int Check(
    const Element& rElement,
    const ProcessInfo& rProcessInfo)
{
    int out = TFluidData::Check(rElement,rProcessInfo);
    return out;
}
 
bool IsCut()
{
    if (IsIncised()) {
        return false;
    } else {
        return (NumPositiveNodes > 0) && (NumNegativeNodes > 0);
    }
}
 
inline bool IsIncised()
{
    return NumIntersectedEdgesExtrapolated > 0 ? true : false;
}
 
 
};
 
 
 
}
 
#endif