embedded_skin_visualization_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//
//
 
#ifndef KRATOS_EMBEDDED_SKIN_VISUALIZATION_PROCESS_H
#define KRATOS_EMBEDDED_SKIN_VISUALIZATION_PROCESS_H
 
// System includes
#include <string>
#include <iostream>
#include <unordered_map>
 
// External includes
#include <boost/functional/hash.hpp> //TODO: remove this dependence when Kratos has en internal one
#include <boost/unordered_map.hpp>   //TODO: remove this dependence when Kratos has en internal one
 
// Project includes
#include "includes/define.h"
#include "includes/key_hash.h"
#include "includes/kratos_parameters.h"
#include "processes/process.h"
#include "utilities/divide_geometry.h"
#include "modified_shape_functions/modified_shape_functions.h"
 
// Application includes
 
 
namespace Kratos
{
 
 
 
 
 
 
 
class KRATOS_API(FLUID_DYNAMICS_APPLICATION) EmbeddedSkinVisualizationProcess : public Process
{
public:
 
    enum class LevelSetType
    {
        Continuous,
        Discontinuous
    };
 
    enum class ShapeFunctionsType
    {
        Ausas,
        Standard
    };
 
    struct Hash{
        std::size_t operator()(const std::pair<unsigned int,bool>& k) const{
            std::size_t h1 = std::hash<unsigned int>()(std::get<0>(k));
            std::size_t h2 = std::hash<bool>()(std::get<1>(k));
            return h1 ^ (h2 << 1);
        }
    };
 
    struct KeyEqual{
        bool operator()(const std::pair<unsigned int,bool>& lhs, const std::pair<unsigned int,bool>& rhs) const{
            return ((std::get<0>(lhs) == std::get<0>(rhs)) && (std::get<1>(lhs) == std::get<1>(rhs)));
        }
    };
 
    KRATOS_CLASS_POINTER_DEFINITION(EmbeddedSkinVisualizationProcess);
 
    typedef std::unordered_map<
        Node::Pointer,
        std::tuple< const Node::Pointer, const Node::Pointer, const double, const double >,
        SharedPointerHasher<Node::Pointer>,
        SharedPointerComparator<Node::Pointer> > CutNodesMapType;
 
 
    static ModelPart& CreateAndPrepareVisualizationModelPart(
        Model& rModel,
        const Parameters rParameters
    );
 
    static void CheckAndSetLevelSetType(
        const Parameters rParameters,
        LevelSetType& rLevelSetType);
 
    static void CheckAndSetShapeFunctionsType(
        const Parameters rParameters,
        ShapeFunctionsType& rShapeFunctionsType);
 
    static const std::string CheckAndReturnDistanceVariableName(
        const Parameters rParameters,
        const LevelSetType& rLevelSetType);
 
    template<class TDataType>
    static void FillVariablesList(
        const Parameters rParameters,
        std::vector<const Variable<TDataType>*>& rVariablesList);
 
 
    EmbeddedSkinVisualizationProcess(
        ModelPart& rModelPart,
        ModelPart& rVisualizationModelPart,
        const std::vector<const Variable< double>* >& rVisualizationScalarVariables,
        const std::vector<const Variable< array_1d<double, 3> >* >& rVisualizationVectorVariables,
        const std::vector<const Variable< double>* >& rVisualizationNonHistoricalScalarVariables,
        const std::vector<const Variable< array_1d<double, 3> >* >& rVisualizationNonHistoricalVectorVariables,
        const LevelSetType& rLevelSetType,
        const ShapeFunctionsType& rShapeFunctionsType,
        const bool ReformModelPartAtEachTimeStep = false);
 
    EmbeddedSkinVisualizationProcess(
        ModelPart& rModelPart,
        ModelPart& rVisualizationModelPart,
        Parameters rParameters);
 
    EmbeddedSkinVisualizationProcess(
        Model& rModel,
        Parameters rParameters);
 
    ~EmbeddedSkinVisualizationProcess() override {}
 
 
 
    void ExecuteBeforeSolutionLoop() override;
 
    void ExecuteBeforeOutputStep() override;
 
    void ExecuteAfterOutputStep() override;
 
    int Check() override;
 
    static Parameters StaticGetDefaultParameters();
 
    const Parameters GetDefaultParameters() const override
    {
        return StaticGetDefaultParameters();
    }
 
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "EmbeddedSkinVisualizationProcess" ;
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override {rOStream << "EmbeddedSkinVisualizationProcess";}
 
    void PrintData(std::ostream& rOStream) const override {}
 
 
 
private:
 
 
 
    // Unordered map to relate the newly created nodes and the origin mesh ones
    CutNodesMapType mCutNodesMap;
 
    // Container with the splitting newly created elements
    ModelPart::ElementsContainerType mNewElementsPointers;
 
    // Reference to the origin model part
    ModelPart& mrModelPart;
 
    // Reference to the visualization model part
    ModelPart& mrVisualizationModelPart;
 
    // Level set type. Current available options continuous and discontinuous
    const LevelSetType mLevelSetType;
 
    // Shape functions type. Current available options ausas and standard
    const ShapeFunctionsType mShapeFunctionsType;
 
    // If true, the visualization model part is created each time step (required in case the level set function is not constant)
    const bool mReformModelPartAtEachTimeStep;
 
    // Pointer to the variable that stores the nodal level set function
    const Variable<double>* mpNodalDistanceVariable;
 
    // Pointer to the variable that stores the elemental level set function
    const Variable<Vector>* mpElementalDistanceVariable;
 
    // Vector containing the scalar variables to be interpolated in the visualization mesh
    const std::vector<const Variable<double>*> mVisualizationScalarVariables;
 
    // Vector containing the vector variables to be interpolated in the visualization mesh
    const std::vector<const Variable<array_1d<double, 3>>*> mVisualizationVectorVariables;
 
    // Vector containing the non-historical scalar variables to be interpolated in the visualization mesh
    const std::vector<const Variable<double>*> mVisualizationNonHistoricalScalarVariables;
 
    // Vector containing the non-historical vector variables to be interpolated in the visualization mesh
    const std::vector<const Variable<array_1d<double, 3>>*> mVisualizationNonHistoricalVectorVariables;
 
 
 
 
    template<bool IsHistorical>
    double& AuxiliaryGetValue(
        Node& rNode,
        const Variable<double>& rVariable);
 
    template<bool IsHistorical>
    array_1d<double,3>& AuxiliaryGetValue(
        Node& rNode,
        const Variable<array_1d<double,3>>& rVariable);
 
    void CreateVisualizationMesh();
 
    void ComputeNewNodesInterpolation();
 
    template<class TDataType, bool IsHistorical>
    void InterpolateVariablesListValues(
        const Node::Pointer& rpNode,
        const Node::Pointer& rpNodeI,
        const Node::Pointer& rpNodeJ,
        const double WeightI,
        const double WeightJ,
        const std::vector<const Variable<TDataType>*>& rVariablesList);
 
    template<const bool IsDistributed>
    void CopyOriginNodes();
 
    void CopyOriginNodalValues();
 
    template<class TDataType, bool IsHistorical>
    void CopyVariablesListValues(
        const ModelPart::NodeIterator& rItOriginNode,
        ModelPart::NodeIterator& rItVisualizationNode,
        const std::vector<const Variable<TDataType>*>& rVariablesList);
 
    void CreateVisualizationGeometries();
 
    template<class TDataType>
    void InitializeNonHistoricalVariables(const std::vector<const Variable<TDataType>*>& rNonHistoricalVariablesVector);
 
    bool ElementIsSplit(
        const Geometry<Node>::Pointer pGeometry,
        const Vector &rNodalDistances);
 
    bool ElementIsIncised(const Vector &rEdgeDistancesExtrapolated);
 
    bool ElementIsPositive(
        Geometry<Node>::Pointer pGeometry,
        const Vector &rNodalDistances);
 
    const Vector SetDistancesVector(ModelPart::ElementIterator ItElem);
 
    const inline Vector SetEdgeDistancesExtrapolatedVector(const Element& rElem);
 
    ModifiedShapeFunctions::Pointer SetModifiedShapeFunctionsUtility(
        const Geometry<Node>::Pointer pGeometry,
        const Vector &rNodalDistances);
 
    ModifiedShapeFunctions::Pointer SetAusasIncisedModifiedShapeFunctionsUtility(
        const Geometry<Node>::Pointer pGeometry,
        const Vector &rNodalDistancesWithExtra,
        const Vector &rEdgeDistancesExtrapolated);
 
    Geometry< Node >::Pointer SetNewConditionGeometry(
        const GeometryData::KratosGeometryType &rOriginGeometryType,
        const Condition::NodesArrayType &rNewNodesArray);
 
    std::tuple< Properties::Pointer , Properties::Pointer > SetVisualizationProperties();
 
    void RemoveVisualizationProperties();
 
    template<const bool IsDistributed>
    static void SetPartitionIndexFromOriginNode(
        const Node& rOriginNode,
        Node& rVisualizationNode);
 
    template<const bool IsDistributed>
    static void SetPartitionIndex(
        const int PartitionIndex,
        Node& rVisualizationNode);
 
 
 
 
    EmbeddedSkinVisualizationProcess() = delete;
 
    EmbeddedSkinVisualizationProcess& operator=(EmbeddedSkinVisualizationProcess const& rOther) = delete;
 
    EmbeddedSkinVisualizationProcess(EmbeddedSkinVisualizationProcess const& rOther) = delete;
 
 
}; // Class EmbeddedSkinVisualizationProcess
 
 
 
 
 
};  // namespace Kratos.
 
#endif // KRATOS_EMBEDDED_SKIN_VISUALIZATION_PROCESS_H