#include <EdgeSizeSimpleImplicit.hpp>

Inheritance diagram for moab::EdgeSizeSimpleImplicit:

Public Member Functions
	EdgeSizeSimpleImplicit ()
	Construct an evaluator.
virtual	~EdgeSizeSimpleImplicit ()
	Destruction is virtual so subclasses may clean up after refinement.
virtual bool	evaluate_edge (const double p0, const void t0, double p1, void t1, const double p2, const void t2)
	Given an edge of length L, true when edge midpoint is within $^2$ of $({2f(x,y,z)}{L})^2$.
virtual void	set_implicit_function (double *coeffs)
	Set the 10 coefficients of the implicit function. The vector contains the entries of A, followed by B, followed by C.
void	get_implicit_function (double *&coeffs)
	Get the 10 coefficients of the implicit function. The vector contains the entries of A, followed by B, followed by C.
virtual void	set_ratio (double r)
	Set the threshold ratio of function value to half-edge length that triggers subdivision.
double	get_ratio ()
	Get the threshold ratio of function value to half-edge length that triggers subdivision.
Protected Attributes
double	coeffA [6]
double	coeffB [3]
double	coeffC
double	ratio

Detailed Description

This is an simple example edge evaluator tha subdivides edges based on their midpoint's distance to a simple, fixed-form implicit surface written as $ x^T A x + B x + C $ where $x$ is a column vector of holding the edge midpoint coordinates, $A$ is a symmetric 3x3 matrix, $B$ is a 1x3 row vector, and $C$ is a scalar. Whenever the implicit function divided by half of the edge length is smaller than some minimum ratio (which defaults to 1), the edge is marked for subdivision.

Author:: David Thompson

Date:: 19 November 2007

Definition at line 37 of file EdgeSizeSimpleImplicit.hpp.

Constructor & Destructor Documentation

moab::EdgeSizeSimpleImplicit::EdgeSizeSimpleImplicit ( )

Construct an evaluator.

Definition at line 5 of file EdgeSizeSimpleImplicit.cpp.

{
  int i;
  // Default to the plane: x = 0.
  this->coeffC = 0.;
  for ( i = 0; i < 3; ++i )
    {
    this->coeffB[i] = this->coeffA[i] = this->coeffA[i+3] = 0.;
    }
  this->coeffB[0] = 1.;
  // Default to a scaling ratio of 1.
  this->ratio = 1.;
}

moab::EdgeSizeSimpleImplicit::~EdgeSizeSimpleImplicit ( ) [virtual]

Destruction is virtual so subclasses may clean up after refinement.

Definition at line 19 of file EdgeSizeSimpleImplicit.cpp.

{
}

Member Function Documentation

bool moab::EdgeSizeSimpleImplicit::evaluate_edge	(	const double *	p0,
		const void *	t0,
		double *	p1,
		void *	t1,
		const double *	p2,
		const void *	t2
	)		`[virtual]`

Given an edge of length L, true when edge midpoint is within $^2$ of $({2f(x,y,z)}{L})^2$.

Implements moab::EdgeSizeEvaluator.

Definition at line 23 of file EdgeSizeSimpleImplicit.cpp.

{
  (void)t0;
  (void)t1;
  (void)t2;
  double L2 = 0.;
  double delta;
  int i;
  for ( i = 0; i < 3; ++i )
    {
    delta = p2[i+3] - p0[i+3];
    L2 += delta * delta;
    }
  // parametric coords in p1[{0,1,2}]
  double x = p1[3];
  double y = p1[4];
  double z = p1[5];
  double F2 =
    this->coeffA[0] * x * x + 2. * this->coeffA[1] * x * y + 2. * this->coeffA[2] * x * z +
    this->coeffA[3] * y * y + 2. * this->coeffA[4] * y * z +
    this->coeffA[5] * z * z +
    this->coeffB[0] * x + this->coeffB[1] * y + this->coeffB[2] * z +
    this->coeffC;
  F2 = F2 * F2; // square it
  double r2 = this->ratio * this->ratio;
  if ( 4. * F2 / L2 < r2 )
    return true; // Midpoint is close to surface => split edge

  return false; // Don't split edge
}

void moab::EdgeSizeSimpleImplicit::get_implicit_function ( double *& coeffs )

Get the 10 coefficients of the implicit function. The vector contains the entries of A, followed by B, followed by C.

Definition at line 70 of file EdgeSizeSimpleImplicit.cpp.

{
  int i;
  // Default to the plane: x = 0.
  for ( i = 0; i < 3; ++i )
    {
    coeffs[i] = this->coeffA[i  ];
    coeffs[i + 3] = this->coeffA[i+3];
    coeffs[i + 6] = this->coeffB[i  ];
    }
  coeffs[9] = this->coeffC;
}

double moab::EdgeSizeSimpleImplicit::get_ratio ( ) [inline]

Get the threshold ratio of function value to half-edge length that triggers subdivision.

Definition at line 60 of file EdgeSizeSimpleImplicit.hpp.

{ return this->ratio; }

void moab::EdgeSizeSimpleImplicit::set_implicit_function ( double * coeffs ) [virtual]

Set the 10 coefficients of the implicit function. The vector contains the entries of A, followed by B, followed by C.

Definition at line 57 of file EdgeSizeSimpleImplicit.cpp.

{
  int i;
  // Default to the plane: x = 0.
  for ( i = 0; i < 3; ++i )
    {
    this->coeffA[i  ] = coeffs[i];
    this->coeffA[i+3] = coeffs[i + 3];
    this->coeffB[i  ] = coeffs[i + 6];
    }
  this->coeffC = coeffs[9];
}

virtual void moab::EdgeSizeSimpleImplicit::set_ratio ( double r ) [inline, virtual]

Set the threshold ratio of function value to half-edge length that triggers subdivision.

Definition at line 58 of file EdgeSizeSimpleImplicit.hpp.