pmmg_utilities.h

Go to the documentation of this file.

// KRATOS  __  __ _____ ____  _   _ ___ _   _  ____
//        |  \/  | ____/ ___|| | | |_ _| \ | |/ ___|
//        | |\/| |  _| \___ \| |_| || ||  \| | |  _
//        | |  | | |___ ___) |  _  || || |\  | |_| |
//        |_|  |_|_____|____/|_| |_|___|_| \_|\____| APPLICATION
//
//  License:         BSD License
//                   license: MeshingApplication/license.txt
//
//  Main authors:    Marc Nunez
//                   Carlos Roig
//                   Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_PMMG_UTILITIES)
#define KRATOS_PMMG_UTILITIES
 
// System includes
 
// External includes
 
// Project includes
#include "custom_utilities/mmg/mmg_utilities.h"
 
// NOTE: The following contains the license of the PMMG library
/* =============================================================================
**  Copyright (c) Bx INP/Inria/UBordeaux, 2017- .
**
**  parmmg 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.
**
**  parmmg 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<PMMGLibrary TPMMGLibrary>
struct PMMGMeshInfo : public MMGMeshInfo<MMGLibrary::MMG3D>
{
};
 
template<PMMGLibrary TPMMGLibrary>
class KRATOS_API(MESHING_APPLICATION) ParMmgUtilities
    : public MmgUtilities<MMGLibrary::MMG3D>
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(ParMmgUtilities);
 
    typedef MmgUtilities<MMGLibrary::MMG3D> BaseType;
 
    typedef Node                                                   NodeType;
    // Geometry definition
    typedef Geometry<NodeType>                                     GeometryType;
 
    static constexpr SizeType Dimension = 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();
 
 
 
 
 
 
 
 
 
    void PrintAndGetParMmgMeshInfo(PMMGMeshInfo<TPMMGLibrary>& rPMMGMeshInfo);
 
    IndexVectorType FindDuplicateNodeIds(const ModelPart& rModelPart) override;
 
    IndexVectorType CheckFirstTypeConditions() override;
 
    IndexVectorType CheckFirstTypeElements() override;
 
    void BlockNode(const IndexType iNode) override;
 
    void BlockCondition(const IndexType iCondition) override;
 
    void BlockElement(const IndexType iElement) override;
 
    NodeType::Pointer CreateNode(
        ModelPart& rModelPart,
        IndexType iNode,
        int& Ref,
        int& IsRequired
        ) override;
 
    Condition::Pointer CreateFirstTypeCondition(
        ModelPart& rModelPart,
        std::unordered_map<IndexType,Condition::Pointer>& rMapPointersRefCondition,
        const IndexType CondId,
        int& Ref,
        int& IsRequired,
        bool SkipCreation
        ) override;
 
    Element::Pointer CreateFirstTypeElement(
        ModelPart& rModelPart,
        std::unordered_map<IndexType,Element::Pointer>& rMapPointersRefElement,
        const IndexType ElemId,
        int& Ref,
        int& IsRequired,
        bool SkipCreation
        ) override;
 
    void InitMesh(const DataCommunicator& rDataCommunicator);
 
    void InitVerbosity() override;
 
    void InitAPIModeParameter(const IndexType VerbosityPMMG);
 
    void InitNodeGloNumParameter(const IndexType nodeGloNum);
 
    void InitVerbosityParameter(const IndexType VerbosityPMMG) override;
 
    void SetMeshSize(PMMGMeshInfo<TPMMGLibrary>& rPMMGMeshInfo);
 
    void SetSolSizeScalar(const SizeType NumNodes) override;
 
    void SetSolSizeVector(const SizeType NumNodes) override;
 
    void SetSolSizeTensor(const SizeType NumNodes) override;
 
    void SetDispSizeVector(const SizeType NumNodes) override;
 
    void CheckMeshData() override;
 
    void InputMesh(const std::string& rInputName) override;
 
    void InputSol(const std::string& rInputName) override;
 
    void OutputMesh(const std::string& rOutputName) override;
 
    void OutputSol(const std::string& rOutputName) override;
 
    void OutputDisplacement(const std::string& rOutputName) override;
 
    void OutputReferenceEntitities(
        const std::string& rOutputName,
        const std::unordered_map<IndexType,Condition::Pointer>& rRefCondition,
        const std::unordered_map<IndexType,Element::Pointer>& rRefElement
        ) override;
 
    void FreeAll() override;
 
    void PMMGLibCallMetric(Parameters ConfigurationParameters);
 
    void PMMGLibCallIsoSurface(Parameters ConfigurationParameters);
 
    void SetNodes(
        const double X,
        const double Y,
        const double Z,
        const IndexType Color,
        const IndexType Index
        ) override;
 
    void SetConditions(
        GeometryType& rGeometry,
        const IndexType Color,
        const IndexType Index
        ) override;
 
    void SetElements(
        GeometryType& rGeometry,
        const IndexType Color,
        const IndexType Index
        ) override;
 
    void SetMetricScalar(
        const double Metric,
        const IndexType NodeId
        ) override;
 
    void SetMetricVector(
        const array_1d<double, Dimension>& rMetric,
        const IndexType NodeId
        ) override;
 
    void SetMetricTensor(
        const TensorArrayType& rMetric,
        const IndexType NodeId
        ) override;
 
    void SetDisplacementVector(
        const array_1d<double, 3>& rDisplacement,
        const IndexType NodeId
        ) override;
 
    void GetMetricScalar(double& rMetric) override;
 
    void GetMetricVector(array_1d<double, Dimension>& rMetric) override;
 
    void GetMetricTensor(TensorArrayType& rMetric) override;
 
    void GetDisplacementVector(array_1d<double, 3>& rDisplacement) override;
 
    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
        ) override;
 
    void GenerateParallelInterfaces(
        ModelPart& rModelPart
    );
 
    void PrintParallelInterfaces(
        ModelPart& rModelPart
    );
 
    void GenerateReferenceMaps(
        ModelPart& rModelPart,
        const ColorsMapType& rColorMapCondition,
        const ColorsMapType& rColorMapElement,
        std::unordered_map<IndexType,Condition::Pointer>& rRefCondition,
        std::unordered_map<IndexType,Element::Pointer>& rRefElement
        ) override;
 
    void GenerateSolDataFromModelPart(ModelPart& rModelPart) override;
 
    void GenerateDisplacementDataFromModelPart(ModelPart& rModelPart) override;
 
    void WriteMeshDataToModelPart(
        ModelPart& rModelPart,
        const std::unordered_map<IndexType,std::vector<std::string>>& rColors,
        const NodeType::DofsContainerType& rDofs,
        const PMMGMeshInfo<TPMMGLibrary>& rPMMGMeshInfo,
        std::unordered_map<IndexType,Condition::Pointer>& rMapPointersRefCondition,
        std::unordered_map<IndexType,Element::Pointer>& rMapPointersRefElement
        );
 
    void WriteReferenceEntitities(
        ModelPart& rModelPart,
        const std::string& rFilename,
        std::unordered_map<IndexType,Condition::Pointer>& rRefCondition,
        std::unordered_map<IndexType,Element::Pointer>& rRefElement
        ) override;
 
    void CreateAuxiliarSubModelPartForFlags(ModelPart& rModelPart) override;
 
    void AssignAndClearAuxiliarSubModelPartForFlags(ModelPart& rModelPart) override;
 
    std::unordered_map<int, int> GetNodalLocalToGlobalMap();
 
 
 
 
 
 
    std::string Info() const // override
    {
        return "ParMmgUtilities";
    }
 
    void PrintInfo(std::ostream& rOStream) const // override
    {
        rOStream << "ParMmgUtilities";
    }
 
    void PrintData(std::ostream& rOStream) const // override
    {
    }
 
protected:
 
 
 
 
 
 
 
 
 
private:
 
 
    std::unordered_map<int, int> mGlobalToLocalNodePreMap;                           
    std::unordered_map<int, int> mGlobalToLocalElemPreMap;                           
    std::unordered_map<int, int> mGlobalToLocalCondPreMap;                           
    std::unordered_map<int, int> mLocalToGlobalNodePostMap;                          
 
 
 
 
 
 
 
 
//     /// Assignment operator.
//     ParMmgUtilities& operator=(ParMmgUtilities const& rOther);
 
//     /// Copy constructor.
//     ParMmgUtilities(ParMmgUtilities const& rOther);
 
 
};// class ParMmgUtilities
 
 
 
 
template<PMMGLibrary TPMMGLibrary>
inline std::istream& operator >> (std::istream& rIStream,
                                  ParMmgUtilities<TPMMGLibrary>& rThis);
 
template<PMMGLibrary TPMMGLibrary>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const ParMmgUtilities<TPMMGLibrary>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}// namespace Kratos.
#endif /* KRATOS_PMMG_UTILITIES defined */