gmHexCellGeometryInfo.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_HEX_CELL_GEOMETRY_INFO_H_
#define _GEMA_HEX_CELL_GEOMETRY_INFO_H_
 
#include "gmCellGeometryInfo.h"
#include "gmCellGeometryIntegrationRuleSet.h"
 
#include "gmGeometryUtils.h"
 
#include "gmHexIntegrationRule.h"
#include "gmHexShape.h"
 
//---------------------------------------------------------
// Hex integration rules
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSet<GmHexGaussIntegrationRule,  GmHexLobattoIntegrationRule,
                                         GmHexNewtonIntegrationRule, GmHexNewtonIntegrationRule> GmHexIntegrationRuleSet;
 
typedef GmCellGeometryIntegrationRuleSet<GmHexGaussFaceIntegrationRule,     GmHexLobattoFaceIntegrationRule,
                                         GmCellGeometryNullIntegrationRule, GmCellGeometryNullIntegrationRule> GmHexFaceIntegrationRuleSet;
 
typedef GmCellGeometryIntegrationRuleSet<GmHexGaussEdgeIntegrationRule,     GmHexLobattoEdgeIntegrationRule,
                                         GmCellGeometryNullIntegrationRule, GmCellGeometryNullIntegrationRule> GmHexEdgeIntegrationRuleSet;
 
//---------------------------------------------------------
// Hex8 rule defaults
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, 2, 2> GmLinearHexIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, -1, -1> GmLinearHexFaceIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, -1, -1> GmLinearHexEdgeIntegrationRuleSetDefaults;
 
//---------------------------------------------------------
// Hex20 & Hex27 rule defaults
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, 2, 2> GmQuadraticHexIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, -1, -1> GmQuadraticHexFaceIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, -1, -1> GmQuadraticHexEdgeIntegrationRuleSetDefaults;
 
 
//---------------------------------------------------------
// GmHex8CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmHex8CellGeometryInfo 
  : public GmCellGeometryInfoSolidElement<GmHexIntegrationRuleSet,     GmLinearHexIntegrationRuleSetDefaults,
                                          GmHexEdgeIntegrationRuleSet, GmLinearHexEdgeIntegrationRuleSetDefaults,
                                          GmHexFaceIntegrationRuleSet, GmLinearHexFaceIntegrationRuleSetDefaults>
{
public:
  static const GmHex8CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmHex8Shape; }
 
  virtual double dimension(const GmMatrix& X) const 
  { 
    return GmGeometryUtils::hexahedronVolume(X.col(0), X.col(1), X.col(2), X.col(3), X.col(4), X.col(5), X.col(6), X.col(7));
  }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const 
  { 
    GmGeometryUtils::hexahedronCentroid(X.col(0), X.col(1), X.col(2), X.col(3), X.col(4), X.col(5), X.col(6), X.col(7), coord);
  }
 
  // ---------  Capabilities API ---------
 
  virtual int isValid(const GmMatrix& X, double tol) const { 
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::hex8PlanarFaces(X, tol)) ret |= GM_GEOMETRY_STATE_NON_PLANAR;
      if (!GmGeometryUtils::hex8IsWellDefined(X))    ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      return ret;
  }
 
  // See comments on the base class
  virtual bool contains(const GmMatrix& X, const GmVector& coord) const { return GmGeometryUtils::pointInHexahedron(X, coord); }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const {Q_UNUSED(X);  R = arma::eye(3, 3); return false; }
 
private:
  GmHex8CellGeometryInfo(GmCellGeometryMetadata&& metadata)
    : GmCellGeometryInfoSolidElement<GmHexIntegrationRuleSet,     GmLinearHexIntegrationRuleSetDefaults,
                                     GmHexEdgeIntegrationRuleSet, GmLinearHexEdgeIntegrationRuleSetDefaults,
                                     GmHexFaceIntegrationRuleSet, GmLinearHexFaceIntegrationRuleSetDefaults>(std::move(metadata)) {}
};
 
//---------------------------------------------------------
// GmHex20CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmHex20CellGeometryInfo 
  : public GmCellGeometryInfoSolidElement<GmHexIntegrationRuleSet,     GmQuadraticHexIntegrationRuleSetDefaults,
                                          GmHexEdgeIntegrationRuleSet, GmQuadraticHexEdgeIntegrationRuleSetDefaults,
                                          GmHexFaceIntegrationRuleSet, GmQuadraticHexFaceIntegrationRuleSetDefaults>
{
public:
  static const GmHex20CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmHex20Shape; }
 
  virtual double dimension(const GmMatrix& X) const { return dimensionByIntegration(X); }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const { centroidByIntegration(X, coord); }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const { Q_UNUSED(X); R = arma::eye(3, 3); return false; }
 
  // ---------  Capabilities API ---------
  virtual int isValid(const GmMatrix& X, double tol) const { 
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::hex20ValidEdges(X))       ret |= GM_GEOMETRY_STATE_BAD_EDGE;
      if (!GmGeometryUtils::hex8PlanarFaces(X, tol))  ret |= GM_GEOMETRY_STATE_NON_PLANAR;
      if (!GmGeometryUtils::hex8IsWellDefined(X))     ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      return ret;
  }
 
private:
  GmHex20CellGeometryInfo(GmCellGeometryMetadata&& metadata)
    : GmCellGeometryInfoSolidElement<GmHexIntegrationRuleSet,     GmQuadraticHexIntegrationRuleSetDefaults,
                                     GmHexEdgeIntegrationRuleSet, GmQuadraticHexEdgeIntegrationRuleSetDefaults,
                                     GmHexFaceIntegrationRuleSet, GmQuadraticHexFaceIntegrationRuleSetDefaults>(std::move(metadata)) {}
};
 
//---------------------------------------------------------
// GmHex27CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmHex27CellGeometryInfo 
  : public GmCellGeometryInfoSolidElement<GmHexIntegrationRuleSet,     GmQuadraticHexIntegrationRuleSetDefaults,
                                          GmHexEdgeIntegrationRuleSet, GmQuadraticHexEdgeIntegrationRuleSetDefaults,
                                          GmHexFaceIntegrationRuleSet, GmQuadraticHexFaceIntegrationRuleSetDefaults>
{
public:
  static const GmHex27CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmHex27Shape; }
 
  virtual double dimension(const GmMatrix& X) const { return dimensionByIntegration(X); }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const { centroidByIntegration(X, coord); }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const { Q_UNUSED(X); R = arma::eye(3, 3); return false; }
  // ---------  Capabilities API ---------
  virtual int isValid(const GmMatrix& X, double tol) const {
 
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::hex27ValidFacesCenter(X, tol)) ret |= GM_GEOMETRY_STATE_BAD_FACE_CENTER;
      if (!GmGeometryUtils::hex20ValidEdges(X))            ret |= GM_GEOMETRY_STATE_BAD_EDGE;
      if (!GmGeometryUtils::hex8PlanarFaces(X, tol))       ret |= GM_GEOMETRY_STATE_NON_PLANAR;
      if (!GmGeometryUtils::hex8IsWellDefined(X))          ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      return ret;
  }
private:
  GmHex27CellGeometryInfo(const GmHex20CellGeometryInfo& hex20)
    : GmCellGeometryInfoSolidElement<GmHexIntegrationRuleSet,     GmQuadraticHexIntegrationRuleSetDefaults,
                                     GmHexEdgeIntegrationRuleSet, GmQuadraticHexEdgeIntegrationRuleSetDefaults,
                                     GmHexFaceIntegrationRuleSet, GmQuadraticHexFaceIntegrationRuleSetDefaults>(hex20) {}
};
 
 
#endif