parametric_affine_transform.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:        BSD License
//                  Kratos default license: kratos/license.txt
//
//  Main Authors:   Máté Kelemen
//
 
#pragma once
 
// Project includes
#include "includes/kratos_parameters.h"
#include "utilities/function_parser_utility.h"
#include "utilities/quaternion.h"
#include "custom_utilities/affine_transform.h"
 
namespace Kratos
{
 
 
 
class KRATOS_API(MESH_MOVING_APPLICATION) ParametricAffineTransform : protected AffineTransform
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ParametricAffineTransform);
 
    using FunctionType = GenericFunctionUtility;
 
 
    ParametricAffineTransform(const Parameters axis,
                              const Parameters angle,
                              const Parameters referencePoint,
                              const Parameters translationVector);
 
    ParametricAffineTransform(const Parameters eulerAngles,
                              const Parameters referencePoint,
                              const Parameters translationVector);
 
 
    array_1d<double,3> Apply(const array_1d<double,3>& rPoint,
                             const double t,
                             const double X = 0.0,
                             const double Y = 0.0,
                             const double Z = 0.0);
 
 
private:
 
 
    // Necessary to parse constants
    static std::string ExtractFunctionBody(const Parameters parameters);
 
    template <std::size_t ArraySize>
    class VectorFunction : public std::array<FunctionType::Pointer,ArraySize>
    {
    public:
        VectorFunction(const Parameters rFunctions)
        {
            KRATOS_TRY
 
            KRATOS_ERROR_IF_NOT(rFunctions.IsArray()) << "VectorFunction can only be constructed from a parameter array";
 
            // Assign components - bounds checks are performed in Parameters::GetArrayItem
            for (std::size_t i=0; i<ArraySize; ++i) {
                const std::string function_string = ExtractFunctionBody(rFunctions.GetArrayItem(i));
                this->at(i) = std::make_shared<GenericFunctionUtility>(function_string);
            }
 
            KRATOS_CATCH("");
        }
 
        VectorFunction(const VectorFunction<ArraySize>& rOther) = default;
 
        array_1d<double,ArraySize> operator()(const double x,
                                              const double y,
                                              const double z,
                                              const double t,
                                              const double X,
                                              const double Y,
                                              const double Z)
    {
        KRATOS_TRY
 
        array_1d<double,ArraySize> output;
 
        for (std::size_t i=0; i<ArraySize; ++i) {
            output[i] = this->at(i)->CallFunction(x, y, z, t, X, Y, Z);
        }
 
        return output;
 
        KRATOS_CATCH("");
    }
    }; // class VectorFunction
 
 
    VectorFunction<3> mReferencePointFunction;
 
    VectorFunction<3> mTranslationVectorFunction;
 
    // The quaternion getter has to be defined at runtime, depending on how the rotation was defined
    std::function<Quaternion<double>(const double, const double, const double, const double, const double, const double, const double)> mQuaternionFunction;
 
    // Store the last quaternion to compare to new ones
    Quaternion<double> mQuaternion;
 
}; // class ParametricAffineTransform
 
 
 
} // namespace Kratos