container_expression_utils.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   license: OptimizationApplication/license.txt
//
//  Main author:     Suneth Warnakulasuriya
//
 
#pragma once
 
// System includes
 
// Project includes
#include "includes/define.h"
#include "spaces/ublas_space.h"
#include "spatial_containers/spatial_containers.h"
#include "expression/container_expression.h"
#include "expression/expression_utils.h"
#include "collective_expression.h"
 
// Application includes
 
namespace Kratos
{
 
 
class KRATOS_API(OPTIMIZATION_APPLICATION) ContainerExpressionUtils
{
public:
 
    using IndexType = std::size_t;
 
    using SparseSpaceType = UblasSpace<double, CompressedMatrix, Vector>;
 
    using SparseMatrixType = SparseSpaceType::MatrixType;
 
 
    template<class TContainerType>
    static double EntityMaxNormL2(const ContainerExpression<TContainerType>& rContainer);
 
    static double InnerProduct(
        const CollectiveExpression& rContainer1,
        const CollectiveExpression& rContainer2);
 
    template<class TContainerType>
    static void ProductWithEntityMatrix(
        ContainerExpression<TContainerType>& rOutput,
        const SparseMatrixType& rMatrix,
        const ContainerExpression<TContainerType>& rInput);
 
    template<class TContainerType>
    static void ProductWithEntityMatrix(
        ContainerExpression<TContainerType>& rOutput,
        const Matrix& rMatrix,
        const ContainerExpression<TContainerType>& rInput);
 
    static void Transpose(
        Matrix& rOutput,
        const Matrix& rInput);
 
    static void Transpose(
        SparseMatrixType& rOutput,
        const SparseMatrixType& rInput);
 
    template<class TContainerType>
    static void ComputeNumberOfNeighbourEntities(
        ContainerExpression<ModelPart::NodesContainerType>& rOutput);
 
    template<class TContainerType>
    static void MapContainerVariableToNodalVariable(
        ContainerExpression<ModelPart::NodesContainerType>& rOutput,
        const ContainerExpression<TContainerType>& rInput,
        const ContainerExpression<ModelPart::NodesContainerType>& rNeighbourEntities);
 
    template<class TContainerType>
    static void MapNodalVariableToContainerVariable(
        ContainerExpression<TContainerType>& rOutput,
        const ContainerExpression<ModelPart::NodesContainerType>& rInput);
 
    template<class TContainerType>
    static void ComputeNodalVariableProductWithEntityMatrix(
        ContainerExpression<ModelPart::NodesContainerType>& rOutput,
        const ContainerExpression<ModelPart::NodesContainerType>& rNodalValues,
        const Variable<Matrix>& rMatrixVariable,
        TContainerType& rEntities);
 
 
    #ifndef KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1
    #define KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1(METHOD_NAME)                              \
        static CollectiveExpression METHOD_NAME(const CollectiveExpression& rCollectiveExpression) \
        {                                                                                          \
            KRATOS_TRY                                                                             \
            auto result = rCollectiveExpression;                                                   \
            auto r_list_of_container_expressions = result.GetContainerExpressions();               \
            for (IndexType i = 0; i < r_list_of_container_expressions.size(); ++i) {               \
                std::visit(                                                                        \
                    [](auto& pResult) {                                                            \
                        *pResult = ExpressionUtils::METHOD_NAME(*pResult);                         \
                    },                                                                             \
                    r_list_of_container_expressions[i]);                                           \
            }                                                                                      \
            return result;                                                                         \
            KRATOS_CATCH("");                                                                      \
        }
    #endif
 
    #ifndef KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_2
    #define KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_2(METHOD_NAME)                \
        static double METHOD_NAME(const CollectiveExpression& rCollectiveExpression) \
        {                                                                            \
            KRATOS_TRY                                                               \
            double value = 0.0;                                                      \
            auto r_list_of_container_expressions =                                   \
                rCollectiveExpression.GetContainerExpressions();                     \
            for (IndexType i = 0; i < r_list_of_container_expressions.size(); ++i) { \
                value += std::visit(                                                 \
                    [](const auto& pResult) {                                        \
                        return ExpressionUtils::METHOD_NAME(*pResult);               \
                    },                                                               \
                    r_list_of_container_expressions[i]);                             \
            }                                                                        \
            return value;                                                            \
            KRATOS_CATCH("");                                                        \
        }
    #endif
 
    #ifndef KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_3
    #define KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_3(METHOD_NAME)                            \
        static CollectiveExpression METHOD_NAME(                                                 \
            const CollectiveExpression& rCollectiveExpression, const double V)                   \
        {                                                                                        \
            KRATOS_TRY                                                                           \
            auto result = rCollectiveExpression;                                                 \
            auto r_list_of_container_expressions = result.GetContainerExpressions();             \
            for (IndexType i = 0; i < r_list_of_container_expressions.size(); ++i) {             \
                std::visit(                                                                      \
                    [V](auto& pResult) {                                                         \
                        *pResult = ExpressionUtils::METHOD_NAME(*pResult, V);                    \
                    },                                                                           \
                    r_list_of_container_expressions[i]);                                         \
            }                                                                                    \
            return result;                                                                       \
            KRATOS_CATCH("");                                                                    \
        }                                                                                        \
        static CollectiveExpression METHOD_NAME(                                                 \
            const CollectiveExpression& rCollectiveExpression1,                                  \
            const CollectiveExpression& rCollectiveExpression2)                                  \
        {                                                                                        \
            KRATOS_TRY                                                                           \
                                                                                                \
            KRATOS_ERROR_IF_NOT(rCollectiveExpression1.IsCompatibleWith(rCollectiveExpression2)) \
                << "Unsupported collective variable data holders provided for "                  \
                "\""                                                                          \
                << #METHOD_NAME << "\"."                                                         \
                << "\nLeft operand : " << rCollectiveExpression1                                 \
                << "\nRight operand: " << rCollectiveExpression2 << std::endl;                   \
                                                                                                \
            auto result = rCollectiveExpression1;                                                \
            auto r_list_of_container_expressions = result.GetContainerExpressions();             \
            const auto& r_right_container_expressions =                                          \
                rCollectiveExpression2.GetContainerExpressions();                                \
            for (IndexType i = 0; i < r_list_of_container_expressions.size(); ++i) {             \
                std::visit(                                                                      \
                    [&r_right_container_expressions, i](auto& pResult) {                         \
                        auto p_right = std::get<std::decay_t<decltype(pResult)>>(                \
                            r_right_container_expressions[i]);                                   \
                        *pResult = ExpressionUtils::METHOD_NAME(*pResult, *p_right);             \
                    },                                                                           \
                    r_list_of_container_expressions[i]);                                         \
            }                                                                                    \
            return result;                                                                       \
                                                                                                \
            KRATOS_CATCH("");                                                                    \
        }
    #endif
 
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1(Collapse)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1(Abs)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1(EntityMin)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1(EntityMax)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1(EntitySum)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_2(Sum)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_2(NormInf)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_2(NormL2)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_3(Pow)
    KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_3(Scale)
 
    #undef KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_1
    #undef KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_2
    #undef KRATOS_OPTAPP_EXPRESSION_UTILS_CEXP_METHOD_3
 
};
 
}