expression_utils.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   license: OptimizationApplication/license.txt
//
//  Main author:     Suneth Warnakulasuriya
//                   Máté Kelemen
//
 
#pragma once
 
// System includes
#include <type_traits>
#include <iterator>
 
// Project includes
#include "includes/define.h"
#include "includes/data_communicator.h"
#include "expression/container_expression.h"
#include "expression/expression.h"
#include "expression/unary_reshape_expression.h"
#include "expression/unary_combine_expression.h"
 
namespace Kratos
{
 
 
class KRATOS_API(KRATOS_CORE) ExpressionUtils
{
public:
 
    using IndexType = std::size_t;
 
 
    static Expression::ConstPointer Collapse(const Expression::ConstPointer& rpExpression);
 
    static Expression::ConstPointer Slice(
        const Expression::ConstPointer& rpExpression,
        std::size_t Offset,
        std::size_t Stride);
 
    template <class TIterator>
    static Expression::ConstPointer Reshape(
        const Expression::ConstPointer& rpExpression,
        TIterator NewShapeBegin,
        TIterator NewShapeEnd)
    {
        static_assert(std::is_same_v<typename std::iterator_traits<TIterator>::value_type,std::size_t>);
        return UnaryReshapeExpression::Create(rpExpression, NewShapeBegin, NewShapeEnd);
    }
 
    static Expression::ConstPointer Reshape(
        const Expression::ConstPointer& rpExpression,
        const std::vector<IndexType>& rNewShape);
 
    static Expression::ConstPointer Comb(const std::vector<Expression::ConstPointer>& rpExpressions);
 
 
    template <class TIterator>
    static Expression::ConstPointer Comb(TIterator ExpressionBegin, TIterator ExpressionEnd)
    {
        static_assert(std::is_same_v<typename std::iterator_traits<TIterator>::value_type,Expression::ConstPointer>
                    || std::is_same_v<typename std::iterator_traits<TIterator>::value_type,Expression::Pointer>);
        return UnaryCombineExpression::Create(ExpressionBegin, ExpressionEnd);
    }
 
    static Expression::ConstPointer Abs(const Expression::ConstPointer& rpExpression);
 
    static Expression::ConstPointer Pow(
        const Expression::ConstPointer& rpExpression,
        const double Power);
 
    static Expression::ConstPointer Pow(
        const Expression::ConstPointer& rpExpression,
        const Expression::ConstPointer& rpPowerpExpression);
 
    static Expression::ConstPointer Scale(
        const Expression::ConstPointer& rpExpression,
        const double Scale);
 
    static Expression::ConstPointer Scale(
        const Expression::ConstPointer& rpExpression,
        const Expression::ConstPointer& rpScaleExpression);
 
    static Expression::ConstPointer EntityMin(const Expression::ConstPointer& rpExpression);
 
    static Expression::ConstPointer EntityMax(const Expression::ConstPointer& rpExpression);
 
    static Expression::ConstPointer EntitySum(const Expression::ConstPointer& rpExpression);
 
 
    static double Sum(
        const Expression::ConstPointer& rpExpression,
        const DataCommunicator& rDataCommunicator);
 
    static double NormInf(
        const Expression::ConstPointer& rpExpression,
        const DataCommunicator& rDataCommunicator);
 
    static double NormL2(
        const Expression::ConstPointer& rpExpression,
        const DataCommunicator& rDataCommunicator);
 
    static double NormP(
        const Expression::ConstPointer& rpExpression,
        const double P,
        const DataCommunicator& rDataCommunicator);
 
    static double InnerProduct(
        const Expression::ConstPointer& rpExpression1,
        const Expression::ConstPointer& rpExpression2,
        const DataCommunicator& rDataCommunicator);
 
 
    #ifndef KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1
    #define KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1(METHOD_NAME)                      \
                          \
        template <class TContainerType>                                             \
        static ContainerExpression<TContainerType> METHOD_NAME(                     \
            const ContainerExpression<TContainerType>& rContainerExpression)        \
        {                                                                           \
            auto copy = rContainerExpression;                                       \
            copy.SetExpression(METHOD_NAME(rContainerExpression.pGetExpression())); \
            return copy;                                                            \
        }
    #endif
 
    #ifndef KRATOS_EXPRESSION_UTILS_CEXP_METHOD_2
    #define KRATOS_EXPRESSION_UTILS_CEXP_METHOD_2(METHOD_NAME)                                     \
                                                                     \
        template <class TContainerType>                                                            \
        static double METHOD_NAME(const ContainerExpression<TContainerType>& rContainerExpression) \
        {                                                                                          \
            return METHOD_NAME(                                                                    \
                rContainerExpression.pGetExpression(),                                             \
                rContainerExpression.GetModelPart().GetCommunicator().GetDataCommunicator());      \
        }
    #endif
 
    #ifndef KRATOS_EXPRESSION_UTILS_CEXP_METHOD_3
    #define KRATOS_EXPRESSION_UTILS_CEXP_METHOD_3(METHOD_NAME)                                   \
                                                                                         \
        template <class TContainerType>                                                          \
        static ContainerExpression<TContainerType> METHOD_NAME(                                  \
            const ContainerExpression<TContainerType>& rContainerExpression, const double Value) \
        {                                                                                        \
            auto copy = rContainerExpression;                                                    \
            copy.SetExpression(METHOD_NAME(rContainerExpression.pGetExpression(), Value));       \
            return copy;                                                                         \
        }                                                                                        \
                                                                                         \
        template <class TContainerType>                                                          \
        static ContainerExpression<TContainerType> METHOD_NAME(                                  \
            const ContainerExpression<TContainerType>& rContainerExpression1,                    \
            const ContainerExpression<TContainerType>& rContainerExpression2)                    \
        {                                                                                        \
            auto copy = rContainerExpression1;                                                   \
            copy.SetExpression(METHOD_NAME(rContainerExpression1.pGetExpression(),               \
                                        rContainerExpression2.pGetExpression()));             \
            return copy;                                                                         \
        }
    #endif
 
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1(Collapse)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1(Abs)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1(EntityMin)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1(EntityMax)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1(EntitySum)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_2(Sum)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_2(NormInf)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_2(NormL2)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_3(Pow)
    KRATOS_EXPRESSION_UTILS_CEXP_METHOD_3(Scale)
 
    #undef KRATOS_EXPRESSION_UTILS_CEXP_METHOD_1
    #undef KRATOS_EXPRESSION_UTILS_CEXP_METHOD_2
    #undef KRATOS_EXPRESSION_UTILS_CEXP_METHOD_3
 
    template<class TContainerType>
    static ContainerExpression<TContainerType> Slice(
        const ContainerExpression<TContainerType>& rContainerExpression,
        std::size_t Offset,
        std::size_t Stride)
    {
        auto copy = rContainerExpression;
        copy.SetExpression(Slice(rContainerExpression.pGetExpression(), Offset, Stride));
        return copy;
    }
 
    template <class TContainerType, class TIterator>
    static ContainerExpression<TContainerType> Reshape(
        const ContainerExpression<TContainerType>& rContainerExpression,
        TIterator NewShapeBegin,
        TIterator NewShapeEnd)
    {
        auto copy = rContainerExpression;
        copy.SetExpression(Reshape(rContainerExpression.pGetExpression(), NewShapeBegin, NewShapeEnd));
        return copy;
    }
 
    template<class TContainerType>
    static ContainerExpression<TContainerType> Reshape(
        const ContainerExpression<TContainerType>& rContainerExpression,
        const std::vector<IndexType>& rNewShape)
    {
        return Reshape(rContainerExpression, rNewShape.begin(), rNewShape.end());
    }
 
    template <class TContainerType>
    static ContainerExpression<TContainerType> Comb(const std::vector<typename ContainerExpression<TContainerType>::Pointer>& rpContainerExpressions)
    {
        std::vector<Expression::ConstPointer> exps;
        std::transform(rpContainerExpressions.begin(), rpContainerExpressions.end(), std::back_inserter(exps), [](const auto& V) { return V->pGetExpression(); });
        KRATOS_ERROR_IF(rpContainerExpressions.empty())
            << "Empty container list provided for combing.";
        auto copy = *rpContainerExpressions.front();
        copy.SetExpression(UnaryCombineExpression::Create(exps.begin(), exps.end()));
        return copy;
    }
 
    template <class TContainerType>
    static double NormP(
        const ContainerExpression<TContainerType>& rContainerExpression,
        const double P)
    {
        return NormP(rContainerExpression.pGetExpression(), P, rContainerExpression.GetModelPart().GetCommunicator().GetDataCommunicator());
    }
 
    template<class TContainerType>
    static double InnerProduct(
        const ContainerExpression<TContainerType>& rContainerExpression1,
        const ContainerExpression<TContainerType>& rContainerExpression2)
    {
        return InnerProduct(rContainerExpression1.pGetExpression(), rContainerExpression2.pGetExpression(), rContainerExpression1.GetModelPart().GetCommunicator().GetDataCommunicator());
    }
 
};
 
}