mmg_utilities.h

Go to the documentation of this file.

// KRATOS  __  __ _____ ____  _   _ ___ _   _  ____
//        |  \/  | ____/ ___|| | | |_ _| \ | |/ ___|
//        | |\/| |  _| \___ \| |_| || ||  \| | |  _
//        | |  | | |___ ___) |  _  || || |\  | |_| |
//        |_|  |_|_____|____/|_| |_|___|_| \_|\____| APPLICATION
//
//  License:         BSD License
//                       license: MeshingApplication/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_MMG_UTILITIES)
#define KRATOS_MMG_UTILITIES
 
// System includes
 
// External includes
 
// Project includes
#include "meshing_application.h"
#include "includes/key_hash.h"
#include "includes/model_part.h"
#include "includes/kratos_parameters.h"
#include "utilities/variable_utils.h"
#include "utilities/assign_unique_model_part_collection_tag_utility.h"
#include "processes/fast_transfer_between_model_parts_process.h"
 
#ifndef MMG_VERSION_GT
    #define MMG_VERSION_GT(MAJOR,MINOR) false
#endif
#ifndef MMG_VERSION_GE
    #define MMG_VERSION_GE(MAJOR,MINOR) false
#endif
#ifndef MMG_VERSION_LT
    #define MMG_VERSION_LT(MAJOR,MINOR) false
#endif
#ifndef MMG_VERSION_LE
    #define MMG_VERSION_LE(MAJOR,MINOR) false
#endif
#ifndef MMG_VERSION_MAJOR
    #define MMG_VERSION_MAJOR 5
#endif
#ifndef MMG_VERSION_MINOR
    #define MMG_VERSION_MINOR 5
#endif
#ifndef MMG_VERSION_PATCH
    #define MMG_VERSION_PATCH 0
#endif
 
#if MMG_VERSION_LT(5,5)
    #error "ERROR:: The minimal MMG compatible version is 5.5.0. Please update your MMG library"
#endif
 
// NOTE: The following contains the license of the MMG library
/* =============================================================================
**  Copyright (c) Bx INP/Inria/UBordeaux/UPMC, 2004- .
**
**  mmg is free software: you can redistribute it and/or modify it
**  under the terms of the GNU Lesser General Public License as published
**  by the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  mmg is distributed in the hope that it will be useful, but WITHOUT
**  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
**  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
**  License for more details.
**
**  You should have received a copy of the GNU Lesser General Public
**  License and of the GNU General Public License along with mmg (in
**  files COPYING.LESSER and COPYING). If not, see
**  <http://www.gnu.org/licenses/>. Please read their terms carefully and
**  use this copy of the mmg distribution only if you accept them.
** =============================================================================
*/
 
namespace Kratos
{
 
 
    typedef std::size_t                                               IndexType;
 
    typedef std::size_t                                                SizeType;
 
    typedef std::vector<IndexType>                              IndexVectorType;
 
 
 
 
template<MMGLibrary TMMGLibrary>
struct MMGMeshInfo
{
    // Info stored
    SizeType NumberOfNodes;
    SizeType NumberOfLines;
    SizeType NumberOfTriangles;
    SizeType NumberOfQuadrilaterals;
    SizeType NumberOfPrism;
    SizeType NumberOfTetrahedra;
 
    SizeType NumberFirstTypeConditions() const;
 
    SizeType NumberSecondTypeConditions() const;
 
    SizeType NumberFirstTypeElements() const;
 
    SizeType NumberSecondTypeElements() const;
};
 
template<MMGLibrary TMMGLibrary>
class KRATOS_API(MESHING_APPLICATION) MmgUtilities
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(MmgUtilities);
 
    typedef Node                                                   NodeType;
    // Geometry definition
    typedef Geometry<NodeType>                                     GeometryType;
 
    static constexpr SizeType Dimension = (TMMGLibrary == MMGLibrary::MMG2D) ? 2 : 3;
 
    typedef typename std::conditional<Dimension == 2, array_1d<double, 3>, array_1d<double, 6>>::type TensorArrayType;
 
    typedef std::vector<double> DoubleVectorType;
 
    typedef std::unordered_map<DoubleVectorType, IndexType, KeyHasherRange<DoubleVectorType>, KeyComparorRange<DoubleVectorType> > DoubleVectorMapType;
 
    typedef std::unordered_map<IndexVectorType, IndexType, KeyHasherRange<IndexVectorType>, KeyComparorRange<IndexVectorType> > IndexVectorMapType;
 
    typedef std::unordered_map<IndexType,IndexType> ColorsMapType;
 
    typedef std::pair<IndexType,IndexType> IndexPairType;
 
    typedef std::pair<IndexType, std::vector<std::string>> IndexStringVectorPairType;
 
    static constexpr double ZeroTolerance = std::numeric_limits<double>::epsilon();
 
 
 
 
 
 
 
 
 
    std::string GetMmgVersion();
 
    void SetEchoLevel(const SizeType EchoLevel);
 
    SizeType GetEchoLevel();
 
    void SetDiscretization(const DiscretizationOption Discretization);
 
    DiscretizationOption GetDiscretization();
 
    void SetRemoveRegions(const bool RemoveRegions);
 
    bool GetRemoveRegions();
 
    void PrintAndGetMmgMeshInfo(MMGMeshInfo<TMMGLibrary>& rMMGMeshInfo);
 
    virtual IndexVectorType FindDuplicateNodeIds(const ModelPart& rModelPart);
 
    virtual IndexVectorType CheckFirstTypeConditions();
 
    virtual IndexVectorType CheckSecondTypeConditions();
 
    virtual IndexVectorType CheckFirstTypeElements();
 
    virtual IndexVectorType CheckSecondTypeElements();
 
    virtual void BlockNode(const IndexType iNode);
 
    virtual void BlockCondition(const IndexType iCondition);
 
    virtual void BlockElement(const IndexType iElement);
 
    virtual NodeType::Pointer CreateNode(
        ModelPart& rModelPart,
        IndexType iNode,
        int& Ref,
        int& IsRequired
        );
 
    virtual Condition::Pointer CreateFirstTypeCondition(
        ModelPart& rModelPart,
        std::unordered_map<IndexType,Condition::Pointer>& rMapPointersRefCondition,
        const IndexType CondId,
        int& Ref,
        int& IsRequired,
        bool SkipCreation
        );
 
    Condition::Pointer CreateSecondTypeCondition(
        ModelPart& rModelPart,
        std::unordered_map<IndexType,Condition::Pointer>& rMapPointersRefCondition,
        const IndexType CondId,
        int& Ref,
        int& IsRequired,
        bool SkipCreation
        );
 
    virtual Element::Pointer CreateFirstTypeElement(
        ModelPart& rModelPart,
        std::unordered_map<IndexType,Element::Pointer>& rMapPointersRefElement,
        const IndexType ElemId,
        int& Ref,
        int& IsRequired,
        bool SkipCreation
        );
 
    Element::Pointer CreateSecondTypeElement(
        ModelPart& rModelPart,
        std::unordered_map<IndexType,Element::Pointer>& rMapPointersRefElement,
        const IndexType ElemId,
        int& Ref,
        int& IsRequired,
        bool SkipCreation
        );
 
    virtual void InitMesh();
 
    virtual void InitVerbosity();
 
    virtual void InitVerbosityParameter(const IndexType VerbosityMMG);
 
    virtual void SetMeshOptimizationModeParameter(const bool EnableMeshOptimization);
 
    void SetMeshSize(MMGMeshInfo<TMMGLibrary>& rMMGMeshInfo);
 
    virtual void SetSolSizeScalar(const SizeType NumNodes);
 
    virtual void SetSolSizeVector(const SizeType NumNodes);
 
    virtual void SetSolSizeTensor(const SizeType NumNodes);
 
    virtual void SetDispSizeVector(const SizeType NumNodes);
 
    virtual void CheckMeshData();
 
    virtual void InputMesh(const std::string& rInputName);
 
    virtual void InputSol(const std::string& rInputName);
 
    virtual void OutputMesh(const std::string& rOutputName);
 
    virtual void OutputSol(const std::string& rOutputName);
 
    virtual void OutputDisplacement(const std::string& rOutputName);
 
    virtual void OutputReferenceEntitities(
        const std::string& rOutputName,
        const std::unordered_map<IndexType,Condition::Pointer>& rRefCondition,
        const std::unordered_map<IndexType,Element::Pointer>& rRefElement
        );
 
    virtual void FreeAll();
 
    void MMGLibCallMetric(Parameters ConfigurationParameters);
 
    void MMGLibCallIsoSurface(Parameters ConfigurationParameters);
 
    virtual void SetNodes(
        const double X,
        const double Y,
        const double Z,
        const IndexType Color,
        const IndexType Index
        );
 
    virtual void SetConditions(
        GeometryType& rGeometry,
        const IndexType Color,
        const IndexType Index
        );
 
    virtual void SetElements(
        GeometryType& rGeometry,
        const IndexType Color,
        const IndexType Index
        );
 
    virtual void SetMetricScalar(
        const double Metric,
        const IndexType NodeId
        );
 
    virtual void SetMetricVector(
        const array_1d<double, Dimension>& rMetric,
        const IndexType NodeId
        );
 
    virtual void SetMetricTensor(
        const TensorArrayType& rMetric,
        const IndexType NodeId
        );
 
    virtual void SetDisplacementVector(
        const array_1d<double, 3>& rDisplacement,
        const IndexType NodeId
        );
 
    virtual void GetMetricScalar(double& rMetric);
 
    virtual void GetMetricVector(array_1d<double, Dimension>& rMetric);
 
    virtual void GetMetricTensor(TensorArrayType& rMetric);
 
    virtual void GetDisplacementVector(array_1d<double, 3>& rDisplacement);
 
    void ReorderAllIds(ModelPart& rModelPart);
 
    virtual void GenerateMeshDataFromModelPart(
        ModelPart& rModelPart,
        std::unordered_map<IndexType,std::vector<std::string>>& rColors,
        ColorsMapType& rColorMapCondition,
        ColorsMapType& rColorMapElement,
        const FrameworkEulerLagrange Framework = FrameworkEulerLagrange::EULERIAN,
        const bool CollapsePrismElements = false
        );
 
    virtual void GenerateReferenceMaps(
        ModelPart& rModelPart,
        const ColorsMapType& rColorMapCondition,
        const ColorsMapType& rColorMapElement,
        std::unordered_map<IndexType,Condition::Pointer>& rRefCondition,
        std::unordered_map<IndexType,Element::Pointer>& rRefElement
        );
 
    virtual void GenerateSolDataFromModelPart(ModelPart& rModelPart);
 
    virtual void GenerateIsosurfaceMetricDataFromModelPart(ModelPart& rModelPart);
 
    virtual void GenerateDisplacementDataFromModelPart(ModelPart& rModelPart);
 
    void WriteMeshDataToModelPart(
        ModelPart& rModelPart,
        const std::unordered_map<IndexType,std::vector<std::string>>& rColors,
        const NodeType::DofsContainerType& rDofs,
        const MMGMeshInfo<TMMGLibrary>& rMMGMeshInfo,
        std::unordered_map<IndexType,Condition::Pointer>& rMapPointersRefCondition,
        std::unordered_map<IndexType,Element::Pointer>& rMapPointersRefElement
        );
 
    void WriteSolDataToModelPart(ModelPart& rModelPart);
 
    virtual void WriteReferenceEntitities(
        ModelPart& rModelPart,
        const std::string& rFilename,
        std::unordered_map<IndexType,Condition::Pointer>& rRefCondition,
        std::unordered_map<IndexType,Element::Pointer>& rRefElement
        );
 
   virtual void CreateAuxiliarSubModelPartForFlags(ModelPart& rModelPart);
 
    virtual void AssignAndClearAuxiliarSubModelPartForFlags(ModelPart& rModelPart);
 
    void SetNumberOfLocalParameters(IndexType NumberOfLocalParameter);
 
    void SetLocalParameter(IndexType rColor, double HMin, double HMax, double HausdorffValue);
 
 
 
 
 
 
    std::string Info() const // override
    {
        return "MmgUtilities";
    }
 
    void PrintInfo(std::ostream& rOStream) const // override
    {
        rOStream << "MmgUtilities";
    }
 
    void PrintData(std::ostream& rOStream) const // override
    {
    }
 
protected:
 
 
 
 
 
 
 
 
 
private:
 
 
    SizeType mEchoLevel = 0;                                               
    bool mRemoveRegions = false;                                           
    DiscretizationOption mDiscretization = DiscretizationOption::STANDARD; 
    bool mUsingMetricTensor = true;                                        
 
 
 
    void ResursivelyAssignFlagEntities(
        ModelPart& rModelPart,
        const Flags& rFlag,
        const bool FlagValue
        )
    {
        // We call it recursively
        for (auto& r_sub_model_part : rModelPart.SubModelParts()) {
            VariableUtils().SetFlag(rFlag, FlagValue, r_sub_model_part.Conditions());
            VariableUtils().SetFlag(rFlag, FlagValue, r_sub_model_part.Elements());
            ResursivelyAssignFlagEntities(r_sub_model_part, rFlag, FlagValue);
        }
    }
 
 
 
 
 
 
//     /// Assignment operator.
//     MmgUtilities& operator=(MmgUtilities const& rOther);
 
//     /// Copy constructor.
//     MmgUtilities(MmgUtilities const& rOther);
 
 
};// class MmgUtilities
 
 
 
 
template<MMGLibrary TMMGLibrary>
inline std::istream& operator >> (std::istream& rIStream,
                                  MmgUtilities<TMMGLibrary>& rThis);
 
template<MMGLibrary TMMGLibrary>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const MmgUtilities<TMMGLibrary>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}// namespace Kratos.
#endif /* KRATOS_MMG_UTILITIES defined */