modified_shape_functions.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_MODIFIED_SHAPE_FUNCTIONS)
#define KRATOS_MODIFIED_SHAPE_FUNCTIONS
 
// System includes
 
// External includes
 
// Project includes
#include "includes/node.h"
#include "geometries/point.h"
#include "geometries/geometry.h"
#include "geometries/geometry_data.h"
#include "utilities/divide_geometry.h"
 
namespace Kratos
{
 
 
 
 
class KRATOS_API(KRATOS_CORE) ModifiedShapeFunctions
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(ModifiedShapeFunctions);
 
    // General type definitions
    typedef Geometry < Node >                                                                    GeometryType;
    typedef GeometryType::Pointer                                                                   GeometryPointerType;
    typedef GeometryType::CoordinatesArrayType                                                      CoordinatesArrayType;
    typedef GeometryData::IntegrationMethod                                                         IntegrationMethodType;
    typedef GeometryData::ShapeFunctionsGradientsType                                               ShapeFunctionsGradientsType;
    typedef std::vector<array_1d<double,3>> AreaNormalsContainerType;
 
    typedef DivideGeometry<Node>::IndexedPointGeometryType                                                IndexedPointGeometryType;
    typedef DivideGeometry<Node>::IndexedPointGeometryPointerType                                         IndexedPointGeometryPointerType;
 
    typedef IntegrationPoint<3>                                                                     IntegrationPointType;
    typedef std::vector<IntegrationPointType>                                                       IntegrationPointsArrayType;
    typedef std::array<IntegrationPointsArrayType, static_cast<int>(GeometryData::IntegrationMethod::NumberOfIntegrationMethods)>      IntegrationPointsContainerType;
 
 
    ModifiedShapeFunctions(const GeometryPointerType pInputGeometry, const Vector& rNodalDistances);
 
    virtual ~ModifiedShapeFunctions();
 
 
 
 
    virtual std::string Info() const;
 
    virtual void PrintInfo(std::ostream& rOStream) const;
 
    virtual void PrintData(std::ostream& rOStream) const;
 
 
 
    virtual const DivideGeometry<Node>::Pointer pGetSplittingUtil() const;
 
    const GeometryPointerType GetInputGeometry() const;
 
    const Vector& GetNodalDistances() const;
 
    double ComputePositiveSideDomainSize() const;
 
    double ComputeNegativeSideDomainSize() const;
 
    void ComputePositiveSideShapeFunctionsAndWeights(
        Matrix &rPositiveSideShapeFunctionsValues,
        Vector &rPositiveSideWeightsValues,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeNegativeSideShapeFunctionsAndWeights(
        Matrix &rNegativeSideShapeFunctionsValues,
        Vector &rNegativeSideWeightsValues,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputePositiveSideShapeFunctionsAndGradientsValues(
        Matrix &rPositiveSideShapeFunctionsValues,
        ShapeFunctionsGradientsType &rPositiveSideShapeFunctionsGradientsValues,
        Vector &rPositiveSideWeightsValues,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeNegativeSideShapeFunctionsAndGradientsValues(
        Matrix &rNegativeSideShapeFunctionsValues,
        ShapeFunctionsGradientsType &rNegativeSideShapeFunctionsGradientsValues,
        Vector &rNegativeSideWeightsValues,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeInterfacePositiveSideShapeFunctionsAndGradientsValues(
        Matrix &rInterfacePositiveSideShapeFunctionsValues,
        ShapeFunctionsGradientsType &rInterfacePositiveSideShapeFunctionsGradientsValues,
        Vector &rInterfacePositiveSideWeightsValues,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeInterfaceNegativeSideShapeFunctionsAndGradientsValues(
        Matrix &rInterfaceNegativeSideShapeFunctionsValues,
        ShapeFunctionsGradientsType &rInterfaceNegativeSideShapeFunctionsGradientsValues,
        Vector &rInterfaceNegativeSideWeightsValues,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputePositiveExteriorFaceShapeFunctionsAndGradientsValues(
        Matrix &rPositiveExteriorFaceShapeFunctionsValues,
        ShapeFunctionsGradientsType &rPositiveExteriorFaceShapeFunctionsGradientsValues,
        Vector &rPositiveExteriorFaceWeightsValues,
        const unsigned int FaceId,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeNegativeExteriorFaceShapeFunctionsAndGradientsValues(
        Matrix &rNegativeExteriorFaceShapeFunctionsValues,
        ShapeFunctionsGradientsType &rNegativeExteriorFaceShapeFunctionsGradientsValues,
        Vector &rNegativeExteriorFaceWeightsValues,
        const unsigned int FaceId,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputePositiveSideInterfaceAreaNormals(
        AreaNormalsContainerType& rPositiveSideInterfaceAreaNormal,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeNegativeSideInterfaceAreaNormals(
        AreaNormalsContainerType& rNegativeSideInterfaceAreaNormal,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputePositiveExteriorFaceAreaNormals(
        AreaNormalsContainerType& rPositiveExteriorFaceAreaNormal,
        const unsigned int FaceId,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeNegativeExteriorFaceAreaNormals(
        AreaNormalsContainerType& rNegativeExteriorFaceAreaNormal,
        const unsigned int FaceId,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeShapeFunctionsOnPositiveEdgeIntersections(Matrix &rPositiveEdgeIntersectionsShapeFunctionsValues);
 
    void ComputeShapeFunctionsOnNegativeEdgeIntersections(Matrix &rNegativeEdgeIntersectionsShapeFunctionsValues);
 
    bool IsSplit() const;
 
 
protected:
 
 
 
 
    virtual void SetCondensationMatrix(Matrix& rIntPointCondMatrix)
    {
        KRATOS_ERROR << "Calling base class \'SetCondensationMatrix\'. Call the derived class one instead." << std::endl;
    }
 
    virtual void SetPositiveSideCondensationMatrix(Matrix& rPosSideCondMatrix)
    {
        KRATOS_ERROR << "Calling base class \'SetPositiveSideCondensationMatrix\'. Call the derived class one instead." << std::endl;
    }
 
    virtual void SetNegativeSideCondensationMatrix(Matrix& rNegSideCondMatrix)
    {
        KRATOS_ERROR << "Calling base class \'SetNegativeSideCondensationMatrix\'. Call the derived class one instead." << std::endl;
    }
 
    void SetCondensationMatrix(
        Matrix& rIntPointCondMatrix,
        const std::vector<int>& rEdgeNodeI,
        const std::vector<int>& rEdgeNodeJ,
        const std::vector<int>& rSplitEdges);
 
    void ComputeValuesOnOneSide(
        Matrix &rShapeFunctionsValues,
        ShapeFunctionsGradientsType &rShapeFunctionsGradientsValues,
        Vector &rWeightsValues,
        const std::vector<IndexedPointGeometryPointerType> &rSubdivisionsVector,
        const Matrix &rPmatrix,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeFaceValuesOnOneSide(
        Matrix &rInterfaceShapeFunctionsValues,
        ShapeFunctionsGradientsType &rInterfaceShapeFunctionsGradientsValues,
        Vector &rInterfaceWeightsValues,
        const std::vector<IndexedPointGeometryPointerType> &rInterfacesVector,
        const std::vector<IndexedPointGeometryPointerType> &rParentGeometriesVector,
        const std::vector<unsigned int> &rInterfacesParentIdsVector,
        const Matrix &rPmatrix,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeFaceNormalOnOneSide(
        AreaNormalsContainerType& rInterfaceAreaNormalValues,
        const std::vector<IndexedPointGeometryPointerType> &rInterfacesVector,
        const IntegrationMethodType IntegrationMethod);
 
    void ComputeEdgeIntersectionValuesOnOneSide(
        const Matrix &rPmatrix,
        Matrix &rEdgeShapeFunctionValues);
 
 
 
 
 
    private :
 
 
    const GeometryPointerType mpInputGeometry;
    const Vector mNodalDistances;
 
 
 
 
    double ComputeDomainSizeOnOneSide(const std::vector<IndexedPointGeometryPointerType> &rSubdivisionsVector) const;
 
    void ComputeValuesOnOneSide(
        Matrix &rShapeFunctionsValues,
        Vector &rWeightsValues,
        const std::vector<IndexedPointGeometryPointerType> &rSubdivisionsVector,
        const Matrix &rPmatrix,
        const IntegrationMethodType IntegrationMethod);
 
 
 
 
    ModifiedShapeFunctions& operator=(ModifiedShapeFunctions const& rOther);
 
    ModifiedShapeFunctions(ModifiedShapeFunctions const& rOther)
        : mpInputGeometry(rOther.mpInputGeometry) , mNodalDistances(rOther.mNodalDistances) {};
 
 
};// class ModifiedShapeFunctions
 
}
#endif /* KRATOS_MODIFIED_SHAPE_FUNCTIONS defined */