Functions.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _FUNCTIONS_H
#define _FUNCTIONS_H
 
#include "Function.h"
 
class TensorFunc;
namespace tinyxml2 { class XMLElement; }
 
using VecTimeFunc = utl::Function<Real,Vec3>; 
 
 
class ConstantFunc : public ScalarFunc
{
  Real fval; 
 
public:
  explicit ConstantFunc(Real v) : fval(v) {}
 
  bool isZero() const override { return fval == Real(0); }
 
protected:
  Real evaluate(const Real&) const override { return fval; }
};
 
 
class LinearFunc : public ScalarFunc
{
  using Point = std::pair<Real,Real>; 
 
  std::vector<Point> fvals; 
  Real               scale; 
 
public:
  explicit LinearFunc(Real s = Real(1)) : scale(s) {}
 
  explicit LinearFunc(const char* file, int c = 2, Real s = Real(1));
 
  LinearFunc(const std::vector<Real>& x, const std::vector<Real>& y);
 
  bool isZero() const override;
  bool isConstant() const override { return fvals.size() == 1; }
 
  Real deriv(Real x) const override;
 
protected:
  Real evaluate(const Real& x) const override;
 
private:
  size_t locate(Real x) const;
};
 
 
class LinVecFunc : public VecTimeFunc
{
  using Point = std::pair<Real,Vec3>; 
 
  std::vector<Point> fvals; 
 
public:
  explicit LinVecFunc(const char* file, int c = 2);
 
  bool isZero() const override;
  bool isConstant() const override { return fvals.size() == 1; }
 
protected:
  Vec3 evaluate(const Real& x) const override;
};
 
 
class RampFunc : public ScalarFunc
{
  Real fval; 
  Real xmax; 
 
public:
  explicit RampFunc(Real f = Real(1), Real x = Real(1)) : fval(f), xmax(x) {}
 
  bool isZero() const override { return fval == Real(0); }
  bool isConstant() const override { return xmax <= Real(0); }
 
  Real deriv(Real x) const override;
 
protected:
  Real evaluate(const Real& x) const override;
};
 
 
class DiracFunc : public ScalarFunc
{
  Real amp;  
  Real xmax; 
 
public:
  explicit DiracFunc(Real a = Real(1), Real x = Real(0)) : amp(a), xmax(x) {}
 
  bool isZero() const override { return amp == Real(0); }
 
protected:
  Real evaluate(const Real& x) const override;
};
 
 
class StepFunc : public ScalarFunc
{
  Real amp;  
  Real xmax; 
 
public:
  explicit StepFunc(Real a, Real x = Real(0)) : amp(a), xmax(x) {}
 
  bool isZero() const override { return amp == Real(0); }
 
protected:
  Real evaluate(const Real& x) const override;
};
 
 
class SineFunc : public ScalarFunc
{
  Real scale; 
  Real freq;  
  Real phase; 
 
public:
  explicit SineFunc(Real s = Real(1), Real f = Real(1), Real p = Real(0))
    : scale(s), freq(f), phase(p) {}
 
  bool isZero() const override { return scale == Real(0); }
  bool isConstant() const override { return this->isZero(); }
 
  Real deriv(Real x) const override;
 
protected:
  Real evaluate(const Real& x) const override;
};
 
 
class ConstFunc : public RealFunc
{
  Real fval; 
 
public:
  explicit ConstFunc(Real v) : fval(v) {}
 
  bool isZero() const override { return fval == Real(0); }
 
protected:
  Real evaluate(const Vec3&) const override { return fval; }
};
 
 
class ConstTimeFunc : public RealFunc
{
  const ScalarFunc* tfunc; 
 
public:
  explicit ConstTimeFunc(const ScalarFunc* f) : tfunc(f) {}
  virtual ~ConstTimeFunc() { delete tfunc; }
 
  bool isZero() const override { return tfunc->isZero(); }
  bool isConstant() const override { return tfunc->isConstant(); }
 
  Real deriv(const Vec3& X, int dir) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class SpaceTimeFunc : public RealFunc
{
  const RealFunc*   sfunc; 
  const ScalarFunc* tfunc; 
 
public:
  SpaceTimeFunc(const RealFunc* s, const ScalarFunc* t) : sfunc(s), tfunc(t) {}
  virtual ~SpaceTimeFunc() { delete sfunc; delete tfunc; }
 
  bool isZero() const override { return sfunc->isZero() || tfunc->isZero(); }
  bool isConstant() const override { return tfunc->isConstant(); }
 
  Real deriv(const Vec3& X, int dir) const override;
  Real dderiv(const Vec3& X, int dir1, int dir2) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class LinearXFunc : public RealFunc
{
  Real a; 
  Real b; 
 
public:
  explicit LinearXFunc(Real A, Real B = Real(0)) : a(A), b(B) {}
 
  bool isZero() const override { return a == Real(0) && b == Real(0); }
 
  Real deriv(const Vec3&, int dir) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class LinearYFunc : public RealFunc
{
  Real a; 
  Real b; 
 
public:
  explicit LinearYFunc(Real A, Real B = Real(0)) : a(A), b(B) {}
 
  bool isZero() const override { return a == Real(0) && b == Real(0); }
 
  Real deriv(const Vec3&, int dir) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class LinearZFunc : public RealFunc
{
  Real a; 
  Real b; 
 
public:
  explicit LinearZFunc(Real A, Real B = Real(0)) : a(A), b(B) {}
 
  bool isZero() const override { return a == Real(0) && b == Real(0); }
 
  Real deriv(const Vec3&, int dir) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class QuadraticXFunc : public RealFunc
{
  Real max; 
  Real a;   
  Real b;   
 
public:
  QuadraticXFunc(Real MAX, Real A, Real B) : max(MAX), a(A), b(B) {}
 
  bool isZero() const override { return max == Real(0); }
 
  Real deriv(const Vec3& X, int dir) const override;
  Real dderiv(const Vec3&, int dir1, int dir2) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class QuadraticYFunc : public RealFunc
{
  Real max; 
  Real a;   
  Real b;   
 
public:
  QuadraticYFunc(Real MAX, Real A, Real B) : max(MAX), a(A), b(B) {}
 
  bool isZero() const override { return max == Real(0); }
 
  Real deriv(const Vec3& X, int dir) const override;
  Real dderiv(const Vec3&, int dir1, int dir2) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class QuadraticZFunc : public RealFunc
{
  Real max; 
  Real a;   
  Real b;   
 
public:
  QuadraticZFunc(Real MAX, Real A, Real B) : max(MAX), a(A), b(B) {}
 
  bool isZero() const override { return max == Real(0); }
 
  Real deriv(const Vec3& X, int dir) const override;
  Real dderiv(const Vec3&, int dir1, int dir2) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class LinearRotZFunc : public RealFunc
{
  bool rX; 
  Real A;  
  Real x0; 
  Real y0; 
 
public:
  LinearRotZFunc(bool retX, Real a, Real x_0 = Real(0), Real y_0 = Real(0))
    : rX(retX), A(a), x0(x_0), y0(y_0) {}
 
  bool isZero() const override { return A == Real(0); }
  bool isConstant() const override { return this->isZero(); }
 
  Real deriv(const Vec3&, int dir) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class StepXFunc : public RealFunc
{
  Real fv; 
  Real x0; 
  Real x1; 
  char d;  
 
public:
  explicit StepXFunc(Real v, Real a = Real(0), Real b = Real(1), char dir = 'X')
    : fv(v), x0(a), x1(b), d(dir) {}
 
  bool isZero() const override { return fv == Real(0); }
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class StepXYFunc : public RealFunc
{
  Real fv; 
  Real x0; 
  Real y0; 
  Real x1; 
  Real y1; 
 
public:
  explicit StepXYFunc(Real v,
                      Real X1 = Real( 1), Real Y1 = Real( 1),
                      Real X0 = Real(-1), Real Y0 = Real(-1))
    : fv(v), x0(X0), y0(Y0), x1(X1), y1(Y1) {}
 
  bool isZero() const override { return fv == Real(0); }
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class Interpolate1D : public RealFunc
{
  LinearFunc lfunc; 
  int        dir;   
  Real       time;  
 
public:
  Interpolate1D(const char* file, int dir_, int col = 2, Real ramp = Real(0))
    : lfunc(file,col), dir(dir_), time(ramp) {}
 
  Interpolate1D(const std::vector<Real>& xVal, const std::vector<Real>& yVal,
                int dir_ = 1, Real ramp = Real(0))
    : lfunc(xVal,yVal), dir(dir_), time(ramp) {}
 
  bool isZero() const override { return lfunc.isZero(); }
  bool isConstant() const override { return time <= Real(0); }
 
  Real deriv(const Vec3&, int ddir) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class ConstVecFunc : public VecFunc
{
  Vec3 fval; 
 
public:
  explicit ConstVecFunc(const Vec3& v) : fval(v) {}
 
  bool isZero() const override { return fval.isZero(0.0); }
 
protected:
  Vec3 evaluate(const Vec3&) const override { return fval; }
};
 
 
class IntFunc : public utl::Function<int,Real>
{
protected:
  Real sf; 
  Real f0; 
 
public:
  explicit IntFunc(Real s = Real(1), Real ofs = Real(0)) : sf(s), f0(ofs) {}
 
protected:
  Real evaluate(const int& x) const override { return f0 + sf*Real(x); }
};
 
 
namespace utl
{
  const RealFunc* parseRealFunc(char* cline, Real A = Real(1),
                                bool print = true);
 
  ScalarFunc* parseTimeFunc(const char* func,
                            const std::string& type = "expression",
                            Real eps = Real(1.0e-8));
 
  VecTimeFunc* parseVecTimeFunc(const char* func,
                                const std::string& type);
 
  RealFunc* parseRealFunc(const std::string& func,
                          const std::string& type = "expression",
                          bool print = true);
 
  RealFunc* parseExprRealFunc(const std::string& function, bool autodiff);
 
  VecFunc* parseExprVecFunc(const std::string& function, bool autodiff);
 
  VecFunc* parseVecFunc(const std::string& func,
                        const std::string& type = "expression",
                        const std::string& variables = "");
 
  TensorFunc* parseTensorFunc(const std::string& func,
                              const std::string& type);
 
  TractionFunc* parseTracFunc(const std::string& func,
                              const std::string& type = "expression",
                              int dir = 0);
 
  TractionFunc* parseTracFunc(const tinyxml2::XMLElement* elem);
}
 
#endif