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 bool isValid(const GmMatrix& X, double tol) const { 
      return GmGeometryUtils::hex8PlanarFaces(X, tol) && GmGeometryUtils::hex8IsWellDefined(X); 
  }

  // See comments on the base class
  virtual bool contains(const GmMatrix& X, const GmVector& coord) const { return GmGeometryUtils::pointInHexahedron(X, coord); }

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); }

  // ---------  Capabilities API ---------
  virtual bool isValid(const GmMatrix& X, double tol) const { 
      return GmGeometryUtils::hex20ValidEdges(X) &&
             GmGeometryUtils::hex8PlanarFaces(X, tol) && 
             GmGeometryUtils::hex8IsWellDefined(X); 
  }

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); }

  // ---------  Capabilities API ---------
  virtual bool isValid(const GmMatrix& X, double tol) const {

      return GmGeometryUtils::hex27ValidFacesCenter(X, tol) &&
             GmGeometryUtils::hex20ValidEdges(X) &&
             GmGeometryUtils::hex8PlanarFaces(X, tol) &&
             GmGeometryUtils::hex8IsWellDefined(X);
  }
private:
  GmHex27CellGeometryInfo(const GmHex20CellGeometryInfo& hex20)
    : GmCellGeometryInfoSolidElement<GmHexIntegrationRuleSet,     GmQuadraticHexIntegrationRuleSetDefaults,
                                     GmHexEdgeIntegrationRuleSet, GmQuadraticHexEdgeIntegrationRuleSetDefaults,
                                     GmHexFaceIntegrationRuleSet, GmQuadraticHexFaceIntegrationRuleSetDefaults>(hex20) {}
};


#endif