pmmg_process.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 Ferrandizz
//
 
#if !defined(KRATOS_PMMG_PROCESS)
#define KRATOS_PMMG_PROCESS
 
// System includes
#include <unordered_set>
#include <unordered_map>
 
// External includes
 
// Project includes
#include "custom_processes/mmg/mmg_process.h"
#include "custom_utilities/parmmg/pmmg_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>
class KRATOS_API(MESHING_APPLICATION) ParMmgProcess
    : public MmgProcess<MMGLibrary::MMG3D>
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(ParMmgProcess);
 
    typedef MmgProcess<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::unordered_map<IndexType,IndexType> ColorsMapType;
 
    typedef std::pair<IndexType,IndexType> IndexPairType;
 
 
 
 
    // Constructor
 
    ParMmgProcess(
        ModelPart& rThisModelPart,
        Parameters ThisParameters = Parameters(R"({})")
        );
 
    ~ParMmgProcess() override = default;
 
 
 
 
 
 
    void operator()();
 
 
    void Execute() override;
 
    void ExecuteInitialize() override;
 
    void ExecuteBeforeSolutionLoop() override;
 
    void ExecuteInitializeSolutionStep() override;
 
    void ExecuteFinalizeSolutionStep() override;
 
    void ExecuteBeforeOutputStep() override;
 
    void ExecuteAfterOutputStep() override;
 
    void ExecuteFinalize() override;
 
    void OutputMdpa() override;
 
    const Parameters GetDefaultParameters() const override;
 
 
 
 
 
 
    std::string Info() const override
    {
        return "ParMmgProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "ParMmgProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
protected:
 
 
 
 
    void InitializeMeshData() override;
 
    void InitializeSolDataMetric() override;
 
    void ExecuteRemeshing() override;
 
    void InitializeElementsAndConditions() override;
 
    void SaveSolutionToFile(const bool PostOutput) override;
 
    void FreeMemory() override;
 
    void ClearConditionsDuplicatedGeometries() override;
 
    void CreateDebugPrePostRemeshOutput(ModelPart& rOldModelPart) override;
 
    template<typename TPointerType>
    void SyncMapAcrossRanks(std::unordered_map<IndexType, TPointerType>& rInputMap);
 
 
 
 
 
 
 
private:
 
 
 
    ParMmgUtilities<TPMMGLibrary> mPMmgUtilities;                     
 
 
 
 
 
 
 
 
    ParMmgProcess& operator=(ParMmgProcess const& rOther);
 
    ParMmgProcess(ParMmgProcess const& rOther);
 
 
};// class ParMmgProcess
 
 
 
 
template<PMMGLibrary TPMMGLibrary>
inline std::istream& operator >> (std::istream& rIStream,
                                  ParMmgProcess<TPMMGLibrary>& rThis);
 
template<PMMGLibrary TPMMGLibrary>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const ParMmgProcess<TPMMGLibrary>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}// namespace Kratos.
#endif /* KRATOS_PMMG_PROCESS defined */