function_parser_utility.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//  Collaborator:    Vicente Mataix Ferrandiz
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/kratos_parameters.h"
 
// Forward declaration to avoid the include of tinyexpr in a header file
struct te_expr;
 
namespace Kratos
{
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) BasicGenericFunctionUtility
{
public:
 
    typedef std::size_t IndexType;
 
    KRATOS_CLASS_POINTER_DEFINITION(BasicGenericFunctionUtility);
 
 
    BasicGenericFunctionUtility(const std::string& rFunctionBody);
 
    BasicGenericFunctionUtility(BasicGenericFunctionUtility const& rOther);
 
    virtual ~BasicGenericFunctionUtility();
 
 
    Pointer Clone()
    {
        return Kratos::make_shared<BasicGenericFunctionUtility>(*this);
    }
 
    virtual bool UseLocalSystem()
    {
        return false;
    }
 
    bool DependsOnSpace()
    {
        return mDependsOnSpace;
    }
 
    std::string FunctionBody();
 
    virtual double RotateAndCallFunction(
        const double x,
        const double y,
        const double z,
        const double t,
        const double X = 0.0,
        const double Y = 0.0,
        const double Z = 0.0
        );
 
    double CallFunction(
        const double x,
        const double y,
        const double z,
        const double t,
        const double X = 0.0,
        const double Y = 0.0,
        const double Z = 0.0
        );
 
 
protected:
 
 
    array_1d<double, 7> mValues = ZeroVector(7);                          
    std::vector<te_expr*> mpTinyExpr = std::vector<te_expr*>(1, nullptr); 
    std::string mFunctionBody;                                            
 
    bool mDependsOnSpace = true;                                          
 
 
    void InitializeParser();
 
}; 
 
class KRATOS_API(KRATOS_CORE) GenericFunctionUtility
  : public BasicGenericFunctionUtility
{
public:
 
    typedef std::size_t IndexType;
 
    KRATOS_CLASS_POINTER_DEFINITION(GenericFunctionUtility);
 
 
    GenericFunctionUtility(
        const std::string& rFunctionBody,
        Parameters LocalSystem = Parameters{}
        );
 
    GenericFunctionUtility(GenericFunctionUtility const& rOther);
 
    ~GenericFunctionUtility() override {};
 
 
    Pointer Clone()
    {
        return Kratos::make_shared<GenericFunctionUtility>(*this);
    }
 
    bool UseLocalSystem() override
    {
        return mUseLocalSystem;
    }
 
    double RotateAndCallFunction(
        const double x,
        const double y,
        const double z,
        const double t,
        const double X = 0.0,
        const double Y = 0.0,
        const double Z = 0.0
        ) override;
 
 
private:
 
 
    bool mUseLocalSystem = false;                
    BoundedMatrix<double, 3, 3> mRotationMatrix; 
    array_1d<double, 3> mCenterCoordinates;      
 
}; 
 
class FunctionParser
{
public:
 
    FunctionParser(const std::string& rFunctionBody)
        : mParser(rFunctionBody)
    {
    }
 
 
    std::function<double(const double, const double, const double)> GetFunctionSpace()
    {
        return [&](const double x, const double y, const double z) -> double {return mParser.CallFunction(x,y,z,0.0);};
    }
 
    std::function<double(const double, const double, const double, const double)> GetFunction()
    {
        return [&](const double x, const double y, const double z, const double t) -> double {return mParser.CallFunction(x,y,z,t);};
    }
 
    std::function<double(const double, const double, const double, const double, const double, const double, const double)> GetFunctionInitialCoordinates()
    {
        return [&](const double x, const double y, const double z, const double t, const double X, const double Y, const double Z) -> double {return mParser.CallFunction(x,y,z,t,X,Y,Z);};;
    }
 
private:
 
    GenericFunctionUtility mParser; 
 
}; 
 
}