/* * Advanced Simulation Library * * Copyright 2015 Avtech Scientific * * * This file is part of Advanced Simulation Library (ASL). * * ASL is free software: you can redistribute it and/or modify it * under the terms of the GNU Affero General Public License as * published by the Free Software Foundation, version 3 of the License. * * ASL is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with ASL. If not, see . * */ #ifndef ASLPOSITIONFUNCTION_H #define ASLPOSITIONFUNCTION_H #include #include "utilities/aslUValue.h" namespace acl { class KernelConfiguration; } namespace asl { template class AVec; class Block; class AbstractDataWithGhostNodes; typedef std::shared_ptr SPAbstractDataWithGhostNodes; /// Abstract class allows to add in kernel distance function from a boundary of a geometrical object ///\ingroup PF /** The class ... */ class PositionFunction { protected: PositionFunction(); public: virtual ~PositionFunction(); virtual acl::VectorOfElements value(acl::VectorOfElements & pos)=0; }; ///\ingroup PF typedef std::shared_ptr SPPositionFunction; ///\ingroup PF class PFBinaryOperation: public PositionFunction { protected: SPPositionFunction e1; SPPositionFunction e2; public: PFBinaryOperation(SPPositionFunction a, SPPositionFunction b); }; ///\ingroup PF class PFUnaryOperation: public PositionFunction { protected: SPPositionFunction e1; public: PFUnaryOperation(SPPositionFunction a); }; ///\ingroup PF class PFOperationPlus: public PFBinaryOperation { public: PFOperationPlus(SPPositionFunction a, SPPositionFunction b); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; ///\ingroup PF class PFOperationMinus: public PFBinaryOperation { public: PFOperationMinus(SPPositionFunction a, SPPositionFunction b); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; ///\ingroup PF class PFOperationProduct: public PFBinaryOperation { public: PFOperationProduct(SPPositionFunction a, SPPositionFunction b); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; ///\ingroup PF class PFOperationInversion: public PFUnaryOperation { public: PFOperationInversion(SPPositionFunction a); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; ///\ingroup PF class PFConstant: public PositionFunction { private: acl::VectorOfElements val; public: PFConstant(acl::VectorOfElements v); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; ///\ingroup PF class PFLinear: public PositionFunction { private: acl::VectorOfElements gradient; acl::VectorOfElements b; public: PFLinear(acl::VectorOfElements g, acl::VectorOfElements p0); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; /// creates function corresponding to a velocity field \ingroup PF class PFRotationField: public PositionFunction { private: acl::VectorOfElements axis; acl::VectorOfElements c; public: /** \param rotationAxis length of the vector corresponds to an angular velocity value */ PFRotationField(acl::VectorOfElements rotationAxis, acl::VectorOfElements center); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; ///\ingroup PF class PFSign: public PFUnaryOperation { public: PFSign(SPPositionFunction a); virtual acl::VectorOfElements value(acl::VectorOfElements & pos); }; ///\ingroup PF SPPositionFunction generatePFLinear(const AVec & g, double p0); ///\ingroup PF template SPPositionFunction generatePFLinear(const AVec & g, UValue p0); ///\ingroup PF SPPositionFunction generatePFConstant(const AVec & a); ///\ingroup PF SPPositionFunction generatePFConstant(double a); ///\ingroup PF SPPositionFunction generatePFRotationField(const AVec & axis, const AVec & c); ///\ingroup PF inline SPPositionFunction operator+(SPPositionFunction a, SPPositionFunction b); ///\ingroup PF inline SPPositionFunction operator-(SPPositionFunction a, SPPositionFunction b); ///\ingroup PF inline SPPositionFunction operator-(SPPositionFunction a); ///\ingroup PF inline SPPositionFunction operator*(SPPositionFunction a, SPPositionFunction b); ///\ingroup PF inline SPPositionFunction sign(SPPositionFunction a); ///\ingroup PF SPAbstractDataWithGhostNodes generateDataContainer_SP(const Block &b, SPPositionFunction df, unsigned int gN, acl::TypeID t); /// Initialize \p d by \p f \ingroup PF void initData(SPAbstractDataWithGhostNodes d, SPPositionFunction f); /// Initialize \p d by \p f \ingroup PF void initData(SPAbstractDataWithGhostNodes d, SPPositionFunction f, const acl::KernelConfiguration & k); //---------------------------- Implementation -------------------------------- inline SPPositionFunction operator+(SPPositionFunction a, SPPositionFunction b) { return SPPositionFunction(new PFOperationPlus(a,b)); } inline SPPositionFunction operator-(SPPositionFunction a, SPPositionFunction b) { return SPPositionFunction(new PFOperationMinus(a,b)); } inline SPPositionFunction operator-(SPPositionFunction a) { return SPPositionFunction(new PFOperationInversion(a)); } inline SPPositionFunction operator*(SPPositionFunction a, SPPositionFunction b) { return SPPositionFunction(new PFOperationProduct(a,b)); } inline SPPositionFunction sign(SPPositionFunction a) { return SPPositionFunction(new PFSign(a)); } }// asl #endif // ASLPositionFunction