rans_line_output_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Suneth Warnakulasuriya
//
 
#if !defined(KRATOS_RANS_LINE_OUTPUT_PROCESS_H_INCLUDED)
#define KRATOS_RANS_LINE_OUTPUT_PROCESS_H_INCLUDED
 
// System includes
#include <string>
 
// External includes
 
// Project includes
#include "containers/model.h"
#include "processes/process.h"
 
namespace Kratos
{
 
namespace LineOutputProcessUtilities
{
 
using NodeType = ModelPart::NodeType;
using GeometryType = ModelPart::ElementType::GeometryType;
using SizeType = std::size_t;
using IndicesVector = std::vector<int>;
 
 
 
template <class TDataType>
class VariableDataCollector
{
public:
    static void inline AddToValuesVector(
        std::vector<double>& rValuesVector,
        const TDataType& rValue,
        const SizeType StartIndex)
    {
        KRATOS_TRY
 
        KRATOS_DEBUG_ERROR_IF(StartIndex >= rValuesVector.size() + rValue.size())
            << "rValuesVector size is not enough to allocate values. "
               "rValuesVector vector should have atleast "
            << rValue.size()
            << " elements from(including) StartIndex value. [ StartIndex = " << StartIndex
            << ", rValuesVector.size() = " << rValuesVector.size() << " ].\n";
 
        for (SizeType i = 0; i < rValue.size(); ++i) {
            rValuesVector[StartIndex + i] += rValue[i];
        }
 
        KRATOS_CATCH("");
    }
 
    static void inline AddNamesToVector(
        std::vector<std::string>& rNamesVector,
        const Variable<TDataType>& rVariable,
        const TDataType& rValue,
        const SizeType StartIndex)
    {
        KRATOS_TRY
 
        KRATOS_DEBUG_ERROR_IF(StartIndex >= rNamesVector.size() + rValue.size())
            << "rNamesVector size is not enough to allocate values. "
               "rNamesVector vector should have atleast "
            << rValue.size()
            << " elements from(including) StartIndex value. [ StartIndex = " << StartIndex
            << ", rNamesVector.size() = " << rNamesVector.size() << " ].\n";
 
        for (SizeType i = 0; i < rValue.size(); ++i) {
            rNamesVector[StartIndex + i] =
                rVariable.Name() + "_" + std::to_string(i + 1);
        }
 
        KRATOS_CATCH("");
    }
 
    static SizeType inline GetVariableDataLength(
        const TDataType& rValue)
    {
        return rValue.size();
    }
};
 
 
template <class TDataType, class TValueGetterFunction>
void inline AddVariablesListNamesToVector(
    std::vector<std::string>& rNamesList,
    const NodeType& rNode,
    const std::vector<const Variable<TDataType>*>& rVariablesList,
    const IndicesVector& rVariableValuesStartIndex,
    TValueGetterFunction* pValueGetterFunction)
{
    for (std::size_t i = 0; i < rVariablesList.size(); ++i) {
        const auto& r_variable = *(rVariablesList[i]);
        VariableDataCollector<TDataType>::AddNamesToVector(
            rNamesList, r_variable, (*pValueGetterFunction)(rNode, r_variable),
            rVariableValuesStartIndex[i]);
    }
}
 
template <class TDataType>
TDataType inline GetHistoricalValue(
    const NodeType& rNode,
    const Variable<TDataType>& rVariable)
{
    return rNode.FastGetSolutionStepValue(rVariable);
}
 
template <class TDataType>
TDataType inline GetNonHistoricalValue(
    const NodeType& rNode,
    const Variable<TDataType>& rVariable)
{
    return rNode.GetValue(rVariable);
}
 
template <class TDataType, class TValueGetterFunction>
IndicesVector GetVariableDataStartIndices(
    const NodeType& rNode,
    const std::vector<const Variable<TDataType>*>& rVariablesList,
    TValueGetterFunction* pValueGetterFunction,
    SizeType& Offset)
{
    const auto number_of_variables = rVariablesList.size();
    IndicesVector start_indices(number_of_variables + 1);
 
    for (SizeType i = 0; i < number_of_variables; ++i) {
        start_indices[i] = Offset;
        Offset += VariableDataCollector<TDataType>::GetVariableDataLength(
            (*pValueGetterFunction)(rNode, *(rVariablesList[i])));
    }
 
    start_indices[number_of_variables] = Offset;
 
    return start_indices;
}
 
template <class TDataType, class TValueGetterFunction>
void inline AddInterpolationContributions(
    std::vector<double>& rValuesList,
    const ModelPart::NodeType& rNode,
    const double ShapeFunctionValue,
    TValueGetterFunction* pValueGetterFunction,
    const IndicesVector& rVariableValuesStartIndex,
    const std::vector<const Variable<TDataType>*>& rVariablesList,
    const SizeType StartIndexOffset)
{
    using variable_data_collector =
        LineOutputProcessUtilities::VariableDataCollector<TDataType>;
 
    for (SizeType i = 0; i < rVariablesList.size(); ++i) {
        variable_data_collector::AddToValuesVector(
            rValuesList, (*pValueGetterFunction)(rNode, *(rVariablesList[i])) * ShapeFunctionValue,
            StartIndexOffset + rVariableValuesStartIndex[i]);
    }
}
 
template <class... TVariableInfoTuplesList>
void InterpolateVariables(
    std::vector<double>& rValuesList,
    const GeometryType& rGeometry,
    const Vector& rSamplingPointShapeFunctions,
    const SizeType LocalSamplePointValuesOffset,
    const TVariableInfoTuplesList&... rVariableInfoTuplesList)
{
    KRATOS_TRY
 
    const SizeType number_of_nodes = rGeometry.PointsNumber();
 
    KRATOS_DEBUG_ERROR_IF(number_of_nodes != rSamplingPointShapeFunctions.size())
        << "number_of_nodes != rSamplingPointShapeFunctions.size().";
 
    for (SizeType i_node = 0; i_node < number_of_nodes; ++i_node) {
        const auto& r_node = rGeometry[i_node];
        const double shape_function_value = rSamplingPointShapeFunctions[i_node];
 
        int dummy[sizeof...(rVariableInfoTuplesList)] = {(
            AddInterpolationContributions(rValuesList, r_node, shape_function_value,
                                          std::get<2>(rVariableInfoTuplesList),
                                          std::get<0>(rVariableInfoTuplesList),
                                          std::get<1>(rVariableInfoTuplesList), LocalSamplePointValuesOffset),
            0)...};
 
        *dummy = 0;
    }
 
    KRATOS_CATCH("");
}
 
 
} // namespace LineOutputProcessUtilities
 
 
class KRATOS_API(RANS_APPLICATION) RansLineOutputProcess
: public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(RansLineOutputProcess);
 
    using NodeType = ModelPart::NodeType;
    using SizeType = std::size_t;
    using IndicesVector = std::vector<int>;
 
 
 
    RansLineOutputProcess(Model& rModel, Parameters rParameters);
 
    ~RansLineOutputProcess() override = default;
 
    RansLineOutputProcess& operator=(RansLineOutputProcess const& rOther) = delete;
 
    RansLineOutputProcess(RansLineOutputProcess const& rOther) = delete;
 
 
    int Check() override;
 
    void ExecuteInitialize() override;
 
    void ExecuteInitializeSolutionStep() override;
 
    void ExecuteFinalizeSolutionStep() override;
 
    const Parameters GetDefaultParameters() const override;
 
 
    std::string Info() const override;
 
    void PrintInfo(std::ostream& rOStream) const override;
 
    void PrintData(std::ostream& rOStream) const override;
 
 
private:
 
    Model& mrModel;
 
    std::string mModelPartName;
    std::vector<std::string> mVariableNames;
    bool mWriteHeader;
    array_1d<double, 3> mStartPoint;
    array_1d<double, 3> mEndPoint;
 
    double mOutputStepInterval;
    double mCurrentStepCount = 0.0;
    double mPreviousStepValue;
    std::string mOutputFileName;
    std::string mOutputStepControlVariableName;
 
    bool mIsHistoricalValue;
    bool mUpdatePointsEachStep;
 
    SizeType mNumberOfSamplingPoints;
    std::vector<double> mSamplingPoints;
    std::vector<int> mSamplingPointElementIds;
    std::vector<Vector> mSamplingPointElementShapeFunctions;
 
    IndicesVector mSamplePointLocalIndexList;
    std::vector<IndicesVector> mSamplePointLocalIndexListMaster;
 
    template <class TDataType>
    using variables_vector_type = std::vector<const Variable<TDataType>*>;
 
    variables_vector_type<double> mDoubleVariablesList;
    variables_vector_type<array_1d<double, 3>> mArray3VariablesList;
    variables_vector_type<array_1d<double, 4>> mArray4VariablesList;
    variables_vector_type<array_1d<double, 6>> mArray6VariablesList;
    variables_vector_type<array_1d<double, 9>> mArray9VariablesList;
    variables_vector_type<Vector> mVectorVariablesList;
    variables_vector_type<Matrix> mMatrixVariablesList;
 
 
    void UpdateSamplePoints();
 
    template <class TDataType>
    bool CheckAndAddVariableToList(
        variables_vector_type<TDataType>& rVariablesList,
        const ModelPart& rModelPart,
        const std::string& rVariableName)
    {
        KRATOS_TRY
 
        if (KratosComponents<Variable<TDataType>>::Has(rVariableName)) {
            const auto& r_variable =
                KratosComponents<Variable<TDataType>>::Get(rVariableName);
            KRATOS_ERROR_IF(mIsHistoricalValue && !rModelPart.HasNodalSolutionStepVariable(r_variable))
                << rVariableName << " is not found in nodal solution step variables list of "
                << rModelPart.Name() << ".";
 
            rVariablesList.push_back(&r_variable);
 
            return true;
        }
 
        return false;
 
        KRATOS_CATCH("");
    }
 
    template <class TOutputDataType, class TDataType>
    void GetVariableValueFromProcessInfo(
        bool& rIsValueObtained,
        TOutputDataType& rOutputValue,
        const std::string& rVariableName) const
    {
        KRATOS_TRY
 
        if (KratosComponents<Variable<TDataType>>::Has(rVariableName)) {
            const auto& r_process_info =
                mrModel.GetModelPart(mModelPartName).GetProcessInfo();
            const auto& r_variable =
                KratosComponents<Variable<TDataType>>::Get(rVariableName);
 
            if (r_process_info.Has(r_variable)) {
                rOutputValue = static_cast<TOutputDataType>(r_process_info[r_variable]);
                rIsValueObtained = true;
            }
        }
 
        KRATOS_CATCH("");
    }
 
    template <class... TDataTypes>
    double CheckAndGetOutputVariableValue(
        const std::string& rVariableName) const
    {
        KRATOS_TRY
 
        bool is_variable_found = false;
        double value = 0.0;
 
        int dummy[sizeof...(TDataTypes)] = {(
            GetVariableValueFromProcessInfo<double, TDataTypes>(is_variable_found, value, rVariableName),
            0)...};
 
        *dummy = 0;
 
        KRATOS_ERROR_IF(!is_variable_found)
            << "Output step control variable name not found in variables list. "
               "[ "
               "output_step_control_variable_name = "
            << rVariableName << " ].\n";
 
        return value;
 
        KRATOS_CATCH("");
    }
 
    bool IsOutputStep();
 
    void WriteOutputFile() const;
 
    void WriteOutputFileHeader(
        std::ofstream& rOutputFileStream) const;
 
    std::string GetOutputFileName() const;
 
 
}; // Class RansLineOutputProcess
 
 
inline std::ostream& operator<<(
    std::ostream& rOStream,
    const RansLineOutputProcess& rThis);
 
 
 
} // namespace Kratos.
 
#endif // KRATOS_RANS_LINE_OUTPUT_PROCESS_H_INCLUDED defined