DualField.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _DUAL_FIELD_H
#define _DUAL_FIELD_H
 
#include "Function.h"
#include "Point.h"
#include <set>
 
class ASMbase;
 
 
class DualRealFunc : public RealFunc
{
  short int comp; 
 
public:
  DualRealFunc(const Vec3& o, const Vec3& n, const Vec3& XZp,
               double d, double w = 0.0, ASMbase* p = nullptr, int c = 0);
  DualRealFunc(const Vec3& o, const Vec3& n,
               double d, double w = 0.0, ASMbase* p = nullptr, int c = 0);
  DualRealFunc(const utl::Point& o, const Vec3Pair& d,
               ASMbase* p = nullptr, double eps = 0.0, int c = 0);
  virtual ~DualRealFunc() {}
 
  virtual unsigned char getType() const
  {
    return comp > 0 && depth <= 0.0 ? 3 : 1;
  }
 
  const Vec3& x() const { return normal; }
  const Vec3& y() const { return tangent; }
  Vec3 z() const { return Vec3(normal,tangent); }
 
  double ecc(const Vec3& X, int i) const { return X(i) - X0(i); }
  double value(const Vec3& X, bool ignoreDomain = false) const;
  bool isPointExtraction() const { return depth <= 0.0; }
  virtual bool inDomain(const Vec3& X) const;
  virtual bool initPatch(size_t idx);
 
protected:
  virtual double evaluate(const Vec3& X) const { return this->value(X); }
 
private:
  utl::Point X0; 
 
  Vec3  normal; 
  Vec3 tangent; 
  double depth; 
  double width; 
  Vec3     Xll; 
  Vec3     Xur; 
 
  ASMbase*      patch; 
  std::set<int> Delem; 
};
 
 
class DualVecFunc : public VecFunc
{
  int comp; 
 
public:
  DualVecFunc(int c, const Vec3& o, const Vec3& n, const Vec3& XZp,
              double d, double w = 0.0, ASMbase* p = nullptr);
  DualVecFunc(int c, const Vec3& o, const Vec3& n,
              double d, double w = 0.0, ASMbase* p = nullptr);
  DualVecFunc(int c, const utl::Point& o, const Vec3Pair& d,
              ASMbase* p = nullptr, double eps = 0.0);
  virtual ~DualVecFunc() {}
 
  virtual unsigned char getType() const { return W.isPointExtraction() ? 3:2; }
 
  virtual bool inDomain(const Vec3& X) const { return W.inDomain(X); }
  virtual bool initPatch(size_t idx) { return W.initPatch(idx); }
 
  const RealFunc& getW() const { return W; }
 
  virtual double getScalarValue(const Vec3& X) const { return W.value(X); }
 
protected:
  virtual Vec3 evaluate(const Vec3& X) const;
 
private:
  DualRealFunc W; 
};
 
#endif