moab
Static Public Member Functions | Static Protected Attributes
moab::LinearHex Class Reference

#include <LinearHex.hpp>

List of all members.

Static Public Member Functions

static ErrorCode evalFcn (const double *params, const double *field, const int ndim, const int num_tuples, double *work, double *result)
 Forward-evaluation of field at parametric coordinates.
static ErrorCode reverseEvalFcn (EvalFcn eval, JacobianFcn jacob, InsideFcn ins, const double *posn, const double *verts, const int nverts, const int ndim, const double iter_tol, const double inside_tol, double *work, double *params, int *is_inside)
 Reverse-evaluation of parametric coordinates at physical space position.
static ErrorCode jacobianFcn (const double *params, const double *verts, const int nverts, const int ndim, double *work, double *result)
 Evaluate the jacobian at a specified parametric position.
static ErrorCode integrateFcn (const double *field, const double *verts, const int nverts, const int ndim, const int num_tuples, double *work, double *result)
 Forward-evaluation of field at parametric coordinates.
static int insideFcn (const double *params, const int ndim, const double tol)
 Function that returns whether or not the parameters are inside the natural space of the element.
static EvalSet eval_set ()
static bool compatible (EntityType tp, int numv, EvalSet &eset)

Static Protected Attributes

static const double corner [8][3]
static const double gauss [1][2] = { { 2.0, 0.0 } }
static const unsigned int corner_count = 8
static const unsigned int gauss_count = 1

Detailed Description

Definition at line 10 of file LinearHex.hpp.

Member Function Documentation

static bool moab::LinearHex::compatible ( EntityType  tp,
int  numv,
EvalSet &  eset 
) [inline, static]

Definition at line 39 of file LinearHex.hpp.

      {
        if (tp == MBHEX && numv == 8) {
          eset = eval_set();
          return true;
        }
        else return false;
      }
static EvalSet moab::LinearHex::eval_set ( ) [inline, static]

Definition at line 34 of file LinearHex.hpp.

      {
        return EvalSet(evalFcn, reverseEvalFcn, jacobianFcn, integrateFcn, (InitFcn)NULL, insideFcn);
      }
ErrorCode moab::LinearHex::evalFcn ( const double *  params,
const double *  field,
const int  ndim,
const int  num_tuples,
double *  work,
double *  result 
) [static]

Forward-evaluation of field at parametric coordinates.

Definition at line 50 of file LinearHex.cpp.

    {
      assert(params && field && num_tuples != -1);
      for (int i = 0; i < num_tuples; i++) result[i] = 0.0;
      for (unsigned i = 0; i < 8; ++i) {
        const double N_i = (1 + params[0]*corner[i][0])
            * (1 + params[1]*corner[i][1])
            * (1 + params[2]*corner[i][2]);
        for (int j = 0; j < num_tuples; j++) result[j] += N_i * field[i*num_tuples+j];
      }
      for (int i = 0; i < num_tuples; i++) result[i] *= 0.125;

      return MB_SUCCESS;
    }
int moab::LinearHex::insideFcn ( const double *  params,
const int  ndim,
const double  tol 
) [static]

Function that returns whether or not the parameters are inside the natural space of the element.

Definition at line 107 of file LinearHex.cpp.

    {
      return EvalSet::inside_function(params, ndim, tol);
    }
ErrorCode moab::LinearHex::integrateFcn ( const double *  field,
const double *  verts,
const int  nverts,
const int  ndim,
const int  num_tuples,
double *  work,
double *  result 
) [static]

Forward-evaluation of field at parametric coordinates.

Definition at line 66 of file LinearHex.cpp.

    {
      assert(field && verts && num_tuples != -1);
      double tmp_result[8];
      ErrorCode rval = MB_SUCCESS;
      for (int i = 0; i < num_tuples; i++) result[i] = 0.0;
      CartVect x;
      Matrix3 J;
      for(unsigned int j1 = 0; j1 < LinearHex::gauss_count; ++j1) {
        x[0] = LinearHex::gauss[j1][1];
        double w1 = LinearHex::gauss[j1][0];
        for(unsigned int j2 = 0; j2 < LinearHex::gauss_count; ++j2) {
          x[1] = LinearHex::gauss[j2][1];
          double w2 = LinearHex::gauss[j2][0];
          for(unsigned int j3 = 0; j3 < LinearHex::gauss_count; ++j3) {
            x[2] = LinearHex::gauss[j3][1];
            double w3 = LinearHex::gauss[j3][0];
            rval = evalFcn(x.array(),field, ndim, num_tuples, NULL, tmp_result);
            if (MB_SUCCESS != rval) return rval;
            rval = jacobianFcn(x.array(), verts, nverts, ndim, work, J[0]);
            if (MB_SUCCESS != rval) return rval;
            double tmp_det =  w1*w2*w3*J.determinant();
            for (int i = 0; i < num_tuples; i++) result[i] += tmp_result[i]*tmp_det;
          }
        }
      }

      return MB_SUCCESS;
    }// LinearHex::integrate_vector()
ErrorCode moab::LinearHex::jacobianFcn ( const double *  params,
const double *  verts,
const int  nverts,
const int  ndim,
double *  work,
double *  result 
) [static]

Evaluate the jacobian at a specified parametric position.

Definition at line 23 of file LinearHex.cpp.

    {
      assert(params && verts);
      Matrix3 *J = reinterpret_cast<Matrix3*>(result);
      *J = Matrix3(0.0);
      for (unsigned i = 0; i < 8; ++i) {
        const double   params_p = 1 + params[0]*corner[i][0];
        const double  eta_p = 1 + params[1]*corner[i][1];
        const double zeta_p = 1 + params[2]*corner[i][2];
        const double dNi_dparams   = corner[i][0] * eta_p * zeta_p;
        const double dNi_deta  = corner[i][1] *  params_p * zeta_p;
        const double dNi_dzeta = corner[i][2] *  params_p *  eta_p;
        (*J)(0,0) += dNi_dparams   * verts[i*ndim+0];
        (*J)(1,0) += dNi_dparams   * verts[i*ndim+1];
        (*J)(2,0) += dNi_dparams   * verts[i*ndim+2];
        (*J)(0,1) += dNi_deta  * verts[i*ndim+0];
        (*J)(1,1) += dNi_deta  * verts[i*ndim+1];
        (*J)(2,1) += dNi_deta  * verts[i*ndim+2];
        (*J)(0,2) += dNi_dzeta * verts[i*ndim+0];
        (*J)(1,2) += dNi_dzeta * verts[i*ndim+1];
        (*J)(2,2) += dNi_dzeta * verts[i*ndim+2];
      }
      (*J) *= 0.125;
      return MB_SUCCESS;
    }// LinearHex::jacobian()
ErrorCode moab::LinearHex::reverseEvalFcn ( EvalFcn  eval,
JacobianFcn  jacob,
InsideFcn  ins,
const double *  posn,
const double *  verts,
const int  nverts,
const int  ndim,
const double  iter_tol,
const double  inside_tol,
double *  work,
double *  params,
int *  is_inside 
) [static]

Reverse-evaluation of parametric coordinates at physical space position.

Definition at line 97 of file LinearHex.cpp.

    {
      assert(posn && verts);
      return EvalSet::evaluate_reverse(eval, jacob, ins, posn, verts, nverts, ndim, iter_tol, inside_tol, work, 
                                       params, is_inside);
    }

Member Data Documentation

const double moab::LinearHex::corner [static, protected]
Initial value:
 { { -1, -1, -1 },
                                             {  1, -1, -1 },
                                             {  1,  1, -1 },
                                             { -1,  1, -1 },
                                             { -1, -1,  1 },
                                             {  1, -1,  1 },
                                             {  1,  1,  1 },
                                             { -1,  1,  1 } }

Definition at line 50 of file LinearHex.hpp.

const unsigned int moab::LinearHex::corner_count = 8 [static, protected]

Definition at line 52 of file LinearHex.hpp.

const double moab::LinearHex::gauss = { { 2.0, 0.0 } } [static, protected]

Definition at line 51 of file LinearHex.hpp.

const unsigned int moab::LinearHex::gauss_count = 1 [static, protected]

Definition at line 53 of file LinearHex.hpp.

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines