mmg_io.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_IO)
#define KRATOS_MMG_IO
 
// System includes
 
// External includes
 
// Project includes
#include "includes/io.h"
#include "includes/model_part.h"
#include "custom_utilities/mmg/mmg_utilities.h"
 
// 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>
class KRATOS_API(MESHING_APPLICATION) MmgIO
    : public IO
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(MmgIO);
 
    typedef ModelPart::NodesContainerType                        NodesArrayType;
    typedef ModelPart::ElementsContainerType                  ElementsArrayType;
    typedef ModelPart::ConditionsContainerType              ConditionsArrayType;
 
    typedef Node                                                   NodeType;
    // Geometry definition
    typedef Geometry<NodeType>                                     GeometryType;
 
    typedef Mesh<NodeType, Properties, Element, Condition>             MeshType;
    typedef MeshType::PropertiesContainerType           PropertiesContainerType;
    typedef MeshType::NodeConstantIterator                 NodeConstantIterator;
    typedef MeshType::ConditionConstantIterator       ConditionConstantIterator;
    typedef MeshType::ElementConstantIterator           ElementConstantIterator;
 
    static constexpr SizeType Dimension = (TMMGLibrary == MMGLibrary::MMG2D) ? 2 : 3;
 
    static constexpr SizeType ConditionsArraySize = (Dimension == 2) ? 1 : 2;
 
    static constexpr SizeType ElementsArraySize = (Dimension == 2) ? 1 : 2;
 
    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;
 
 
 
    // Constructor
 
    MmgIO(
        std::string const& rFilename,
        Parameters ThisParameters = Parameters(R"({})"),
        const Flags Options = IO::READ | IO::IGNORE_VARIABLES_ERROR.AsFalse() | IO::SKIP_TIMER);
 
    ~MmgIO() override = default;
 
 
 
 
 
 
 
    void ReadModelPart(ModelPart& rModelPart) override;
 
    void WriteModelPart(ModelPart& rModelPart) override;
 
    std::string GetMmgVersion();
 
 
 
 
 
 
    std::string Info() const override
    {
        return "MmgIO";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "MmgIO";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
protected:
 
 
 
 
 
 
 
 
 
private:
 
 
    std::string mFilename;                       
    Parameters mThisParameters;                  
    Flags mOptions;                              
 
    MmgUtilities<TMMGLibrary> mMmgUtilities;     
 
 
 
    Parameters GetDefaultParameters()
    {
        Parameters default_parameters = Parameters(R"(
        {
            "echo_level"                           : 0
        })" );
 
        return default_parameters;
    }
 
 
 
 
 
 
//     /// Assignment operator.
//     MmgIO& operator=(MmgIO const& rOther);
 
//     /// Copy constructor.
//     MmgIO(MmgIO const& rOther);
 
 
};// class MmgIO
 
 
 
 
template<MMGLibrary TMMGLibrary>
inline std::istream& operator >> (std::istream& rIStream,
                                  MmgIO<TMMGLibrary>& rThis);
 
template<MMGLibrary TMMGLibrary>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const MmgIO<TMMGLibrary>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}// namespace Kratos.
#endif /* KRATOS_MMG_IO defined */