vtu_output.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Suneth Warnakulasuriya
//
 
#pragma once
 
// System includes
#include <string>
#include <variant>
#include <unordered_map>
#include <map>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/io.h"
#include "includes/model_part.h"
#include "containers/variable.h"
#include "containers/flags.h"
#include "expression/container_expression.h"
 
namespace Kratos {
class KRATOS_API(KRATOS_CORE) VtuOutput : public IO
{
public:
 
    using IndexType = std::size_t;
 
    using SupportedVariables = std::variant<
                                    const Variable<int>*,
                                    const Variable<double>*,
                                    const Variable<array_1d<double, 3>>*,
                                    const Variable<array_1d<double, 4>>*,
                                    const Variable<array_1d<double, 6>>*,
                                    const Variable<array_1d<double, 9>>*>;
 
    using SupportedCellContainerExpressions = std::variant<
                                                ContainerExpression<ModelPart::ConditionsContainerType>::Pointer,
                                                ContainerExpression<ModelPart::ElementsContainerType>::Pointer>;
 
    KRATOS_CLASS_POINTER_DEFINITION(VtuOutput);
 
    KRATOS_DEFINE_LOCAL_FLAG( NODES );
    KRATOS_DEFINE_LOCAL_FLAG( CONDITIONS );
    KRATOS_DEFINE_LOCAL_FLAG( ELEMENTS );
 
 
    enum WriterFormat
    {
        ASCII,  
        BINARY  
    };
 
 
    VtuOutput(
        ModelPart& rModelPart,
        const bool IsInitialConfiguration = true,
        const WriterFormat OutputFormat = WriterFormat::BINARY,
        const IndexType Precision = 9);
 
 
    template<class TDataType>
    void AddHistoricalVariable(const Variable<TDataType>& rVariable);
 
    template<class TDataType>
    void AddNonHistoricalVariable(
        const Variable<TDataType>& rVariable,
        const Flags& rEntityFlags);
 
    void AddFlagVariable(
        const std::string& rFlagName,
        const Flags& rFlagVariable,
        const Flags& rEntityFlags);
 
    template <class TContainerType>
    void AddContainerExpression(
        const std::string& rExpressionName,
        const typename ContainerExpression<TContainerType>::Pointer pContainerExpression);
 
    void ClearHistoricalVariables();
 
    void ClearNodalNonHistoricalVariables();
 
    void ClearCellNonHistoricalVariables();
 
    void ClearNodalFlags();
 
    void ClearCellFlags();
 
    void ClearNodalContainerExpressions();
 
    void ClearCellContainerExpressions();
 
    const ModelPart& GetModelPart() const;
 
    void PrintOutput(const std::string& rOutputFilenamePrefix);
 
private:
 
    ModelPart& mrModelPart; 
 
    const bool mIsInitialConfiguration; 
 
    const WriterFormat mOutputFormat; 
 
    const IndexType mPrecision; 
 
    bool mIsConditionsConsidered; 
 
    bool mIsElementsConsidered; 
 
    // TODO: In the future study to replace the std::map
    // TODO: Study replace string, expensive, with hashes or keys
 
    std::unordered_map<IndexType, IndexType> mKratosVtuIndicesMap; 
 
    std::map<std::string, SupportedVariables> mHistoricalVariablesMap; 
 
    std::map<std::string, SupportedVariables> mNonHistoricalNodalVariablesMap; 
 
    std::map<std::string, SupportedVariables> mNonHistoricalCellVariablesMap; 
 
    std::map<std::string, const Flags*> mNodalFlagsMap; 
 
    std::map<std::string, const Flags*> mCellFlagsMap; 
 
    std::map<std::string, ContainerExpression<ModelPart::NodesContainerType>::Pointer> mPointContainerExpressionsMap; 
 
    std::map<std::string, SupportedCellContainerExpressions> mCellContainerExpressionsMap; 
 
 
    void PrintModelPart(
        const std::string& rOutputFileNamePrefix,
        ModelPart& rModelPart) const;
 
};
} // namespace Kratos