gmInt2dCellGeometryInfo.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_INT2D_CELL_GEOMETRY_INFO_H_
#define _GEMA_INT2D_CELL_GEOMETRY_INFO_H_
 
#include "gmCellGeometryInfo.h"
#include "gmCellGeometryIntegrationRuleSet.h"
 
#include "gmGeometryUtils.h"
 
#include "gmBarIntegrationRule.h"
#include "gmQuadIntegrationRule.h"
#include "gmInt2DShape.h"
 
//---------------------------------------------------------
// Int2D integration rules
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSet<GmLineGaussIntegrationRule,  GmLineLobattoIntegrationRule,
                                         GmLineNewtonIntegrationRule, GmLineNewtonIntegrationRule> GmInt2DIntegrationRuleSet;
 
typedef GmCellGeometryIntegrationRuleSet<GmQuadGaussEdgeIntegrationRule,    GmQuadLobattoEdgeIntegrationRule,
                                         GmCellGeometryNullIntegrationRule, GmCellGeometryNullIntegrationRule> GmInt2DEdgeIntegrationRuleSet;
 
//---------------------------------------------------------
// Int2DL4 & Int2DL6 rule defaults
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, 2, 2> GmLinearInt2DIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, -1, -1> GmLinearInt2DEdgeIntegrationRuleSetDefaults;
 
//---------------------------------------------------------
// Int2DQ6 & Int2DQ8 rule defaults
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 3, 3, 3, 3> GmQuadraticInt2DIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 3, 3, -1, -1> GmQuadraticInt2DEdgeIntegrationRuleSetDefaults;
 
 
//---------------------------------------------------------
// GmInt2DL4CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmInt2DL4CellGeometryInfo
  : public GmCellGeometryInfoSurfaceElement<GmInt2DIntegrationRuleSet,     GmLinearInt2DIntegrationRuleSetDefaults,
                                            GmInt2DEdgeIntegrationRuleSet, GmLinearInt2DEdgeIntegrationRuleSetDefaults>
{
public:
  static const GmInt2DL4CellGeometryInfo* 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 GmInt2DL4Shape; }
 
  virtual double dimension(const GmMatrix& X) const 
  { 
    return GmGeometryUtils::edgeLength(0.5*(X.col(0)+X.col(3)), 0.5*(X.col(1)+X.col(2)));
  }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const 
  { 
    GmGeometryUtils::edgeCentroid(0.5*(X.col(0)+X.col(3)), 0.5*(X.col(1)+X.col(2)), coord);
  }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const { 
          GmVector p1 = (X.col(1) + X.col(2)) * 0.5;
          GmVector p0 = (X.col(0) + X.col(3)) * 0.5;
          return GmGeometryUtils::computeLocalAxis2(p1 - p0, R);
  }
 
  // ---------  Capabilities API ---------
 
  virtual int isValid(const GmMatrix& X, double tol) const { 
     Q_UNUSED(tol); 
     int ret = GM_GEOMETRY_STATE_VALID;
     if (!GmGeometryUtils::polygon2DIsCCW(X)) ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
     return ret;
  }
 
protected:
  GmInt2DL4CellGeometryInfo(GmCellGeometryMetadata&& metadata)
    : GmCellGeometryInfoSurfaceElement<GmInt2DIntegrationRuleSet,     GmLinearInt2DIntegrationRuleSetDefaults,
                                       GmInt2DEdgeIntegrationRuleSet, GmLinearInt2DEdgeIntegrationRuleSetDefaults>(std::move(metadata)) {}
};
 
//---------------------------------------------------------
// GmInt2DL6CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmInt2DL6CellGeometryInfo : public GmInt2DL4CellGeometryInfo
{
public:
  static const GmInt2DL6CellGeometryInfo* 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 GmInt2DL6Shape; }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const { 
          GmVector p1 = (X.col(1) + X.col(2)) * 0.5;
          GmVector p0 = (X.col(0) + X.col(3)) * 0.5;
          return GmGeometryUtils::computeLocalAxis2(p1 - p0, R);
  }
 
  // ---------  Capabilities API ---------
 
  virtual int isValid(const GmMatrix& X, double tol) const {
      Q_UNUSED(tol);
      //reorder nodes
      constexpr int order[] = { 0,1,5,2,3,4 };
      GmMatrix Xr = GmGeometryUtils::shuffle(X, order, 6);
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::polygon2DIsCCW(Xr)) ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      return ret;
  }
 
private:
  GmInt2DL6CellGeometryInfo(GmCellGeometryMetadata&& metadata) : GmInt2DL4CellGeometryInfo(std::move(metadata)) {}
};
 
//---------------------------------------------------------
// GmInt2DQ6CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmInt2DQ6CellGeometryInfo
  : public GmCellGeometryInfoSurfaceElement<GmInt2DIntegrationRuleSet,     GmQuadraticInt2DIntegrationRuleSetDefaults,
                                            GmInt2DEdgeIntegrationRuleSet, GmQuadraticInt2DEdgeIntegrationRuleSetDefaults>
{
public:
  static const GmInt2DQ6CellGeometryInfo* 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 GmInt2DQ6Shape; }
 
  virtual double dimension(const GmMatrix& X) const
  {
    GmMatrix Xm(2, 3);
    Xm.col(0) = 0.5*(X.col(0)+X.col(3));  // First node
    Xm.col(1) = 0.5*(X.col(1)+X.col(2));  // Last node
    Xm.col(2) = 0.5*(X.col(4)+X.col(5));  // Mid node 
    return GmCellGeometry::geometryInfo(GM_BAR3)->dimensionByIntegration(Xm);
  }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const
  {
    GmMatrix Xm(2, 3);
    Xm.col(0) = 0.5*(X.col(0)+X.col(3));  // First node
    Xm.col(1) = 0.5*(X.col(1)+X.col(2));  // Last node
    Xm.col(2) = 0.5*(X.col(4)+X.col(5));  // Mid node 
    GmCellGeometry::geometryInfo(GM_BAR3)->centroidByIntegration(Xm, coord);
  }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const { 
          GmVector p1 = (X.col(1) + X.col(2)) * 0.5;
          GmVector p0 = (X.col(0) + X.col(3)) * 0.5;
          return GmGeometryUtils::computeLocalAxis2(p1 - p0, R);
  }
 
  // ---------  Capabilities API ---------
 
  virtual int isValid(const GmMatrix& X, double tol) const {
      Q_UNUSED(tol);
      //reorder nodes
      constexpr int order[] = {0,4,1,2,5,3};
      GmMatrix Xr = GmGeometryUtils::shuffle(X, order, 6);
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::polygon2DIsCCW(Xr)) ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      return ret;
  }
 
protected:
  GmInt2DQ6CellGeometryInfo(GmCellGeometryMetadata&& metadata)
    : GmCellGeometryInfoSurfaceElement<GmInt2DIntegrationRuleSet,     GmQuadraticInt2DIntegrationRuleSetDefaults,
                                       GmInt2DEdgeIntegrationRuleSet, GmQuadraticInt2DEdgeIntegrationRuleSetDefaults>(std::move(metadata)) {}
};
 
 
//---------------------------------------------------------
// GmInt2DQ8CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmInt2DQ8CellGeometryInfo : public GmInt2DQ6CellGeometryInfo
{
public:
  static const GmInt2DQ8CellGeometryInfo* 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 GmInt2DQ8Shape; }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const { 
          GmVector p1 = (X.col(1) + X.col(2)) * 0.5;
          GmVector p0 = (X.col(0) + X.col(3)) * 0.5;
          return GmGeometryUtils::computeLocalAxis2(p1 - p0, R);
  }
 
  // ---------  Capabilities API ---------
 
  virtual int isValid(const GmMatrix& X, double tol) const {
      Q_UNUSED(tol);
      //reorder nodes
      constexpr int order[] = {0,4,1,7,2,5,3,6};
      GmMatrix Xr = GmGeometryUtils::shuffle(X, order, 8);
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::polygon2DIsCCW(Xr)) ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      return ret;
  }
 
private:
  GmInt2DQ8CellGeometryInfo(GmCellGeometryMetadata&& metadata) : GmInt2DQ6CellGeometryInfo(std::move(metadata)) {}
};
 
#endif