gmCellGeometryInfo.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_CELL_GEOMETRY_INFO_H_
#define _GEMA_CELL_GEOMETRY_INFO_H_
 
#include "gmCoreConfig.h"
#include "gmCellType.h"  
#include "gmIntegrationRule.h"
#include "gmMatrix.h"
#include "gmVector.h"
 
#include <QAtomicPointer>
#include <QMutex>
 
class GmShape;
class GmBorderIntegrationRule;
 
enum GmCellGeometryCapabilities
{
  // IMPORTANT: DO NOT CHANGE THE ORDER OF THE ENUM BELOW without changing the order 
  //            used to fill the GmCellGeometryMetadata._capabilities vector for 
  //            EVERY GmCellGeometryInfo derived class!!!!
  //            Also, when ADDING entries, rember to fill the said vector in EVERY derived class.
  GM_CELL_GEOMETRY_VALID,    
  GM_CELL_GEOMETRY_QUALITY,  
  GM_CELL_GEOMETRY_CONTAINS, 
  // ----------------------------
  // No adding after this line
  GM_CELL_GEOMETRY_CAPABILITY_COUNT,  
};
 
enum GmCellGeometryValidity
{
    GM_GEOMETRY_STATE_VALID           = 0b000000, //Valid geometry
    GM_GEOMETRY_STATE_NON_PLANAR      = 0b000001, //Invalid geometry with non-planar faces
    GM_GEOMETRY_STATE_BAD_ORIENTATION = 0b000010, //Invalid geometry with bad orientation/negative volume
    GM_GEOMETRY_STATE_BAD_EDGE        = 0b000100, //Invalid geometry with invalid quadratic edge
    GM_GEOMETRY_STATE_BAD_FACE_CENTER = 0b001000, //Invalid geometry with invalid quadratic face center
    GM_GEOMETRY_STATE_SELF_INTERSECT  = 0b010000, //Invalid geometry, self-intersection
        GM_GEOMETRY_STATE_INVALID_NODES   = 0b100000, //Invalid geometry, repeated/out of range nodes
};
 
struct GMC_API_EXPORT GmCellGeometryMetadata
{
  struct EdgeNodeData
  {
    GmCellType _eqEdgeType;
 
    GmCellType _meshEdgeType;
 
    QVector<int> _edgeNodes;
  };
 
  struct FaceNodeData
  {
    int _nboundaryNodes; 
 
    GmCellType _eqFaceType;     
 
    GmCellType _meshFaceType;
 
    QVector<int> _faceNodes;
 
    QVector<int> _faceTypeNodes;
 
    QVector<int> _meshTypeNodes;
  };
 
  struct InterfaceData
  {
    QVector<int>          _contactSides;  
    QVector<int>          _apertureSides; 
    QVector<QVector<int>> _contactEdges;  
    QVector<QVector<int>> _apertureEdges; 
  };
 
  GmCellType       _type;           
  const char*      _name;           
  GmCellFamilyType _family;         
  bool             _interface;      
  bool             _hierarchical;   
  int              _order;          
  GmCellType       _eqLinearType;   
  int              _nnodes;         
  int              _nvertices;      
  int              _nextraDofNodes; 
  int              _ncoord;         
  int              _nedges;         
  int              _nfaces;         
  int              _nfaceTypes;     
 
  // A vector storing true or false to specifiy if a cell type has the capabilities listed in GmCellGeometryCapabilities
  bool _capabilities[GM_CELL_GEOMETRY_CAPABILITY_COUNT];
 
  QVector<EdgeNodeData> _edgeNodeInfo; 
 
  QVector<QVector<int>> _faceEdgeInfo;
 
  QVector<QVector<int>> _edgeFaceInfo;
 
  QVector<FaceNodeData> _faceNodeInfo;
 
  InterfaceData _interfaceInfo;
 
  QVector<QVector<int>> _nodeIncidenceInfo;
 
  QVector<int> _volumeNodeInfo;
 
  GmCellGeometryMetadata(const GmCellGeometryMetadata& other) = default;
 
  GmCellGeometryMetadata(GmCellGeometryMetadata&& other) = default;
};
 
 
/* \brief An interface that links a cell geometric metadata with the associated
          shape function and integration rules through factory methods that can
          create those associated objects. It also implements the geometric routines
          specifica for a type (like length and area calculation routines).
 
   This interface should be instanced only by way of derived classes that make the
   concrete link with the shape function / integration rules.
 
   If in the future we need to support an hypotetic cell type that has no associated
   shape function or integration rule (a cell type that is not an element type), a
   derived class that returns NULL for all factory methods can be implemented.
*/
class GMC_API_EXPORT GmCellGeometryInfo : public GmCellGeometryMetadata
{
public:
  GmCellGeometryInfo(const GmCellGeometryInfo& other) : GmCellGeometryMetadata(other) {}
 
  GmCellGeometryInfo(GmCellGeometryMetadata&& metadata) : GmCellGeometryMetadata(std::move(metadata)) {}
 
  virtual GmShape* shapeInstance(int P, int Q) const = 0;
 
  virtual GmIntegrationRule* integrationRule(GmIntegrationRuleType irType, int rule1, int rule2, int rule3, int P, int Q) const = 0;
 
  virtual GmBorderIntegrationRule* edgeIntegrationRule(GmIntegrationRuleType irType, int rule1, int P, int Q) const = 0;
 
  virtual GmBorderIntegrationRule* faceIntegrationRule(int faceType, GmIntegrationRuleType irType, int rule1, int rule2, int P, int Q) const = 0;
  
 
  virtual double dimension(const GmMatrix& X) const = 0;
 
  virtual bool localAxis(const GmMatrix& X, GmMatrix& R) const = 0;
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const = 0;
 
  // 
  // Capability related methods. Must be implmented on every derived classes that
  // do implement the capability and should be IN SYNC with the information 
  // stored in the associeted GmCellGeometryMetadata _capabilities field.
  //------------------------------------------------------------------------------------
 
  virtual int isValid(const GmMatrix& X, double tol) const { Q_UNUSED(tol);  Q_UNUSED(X); return GM_GEOMETRY_STATE_VALID; }
 
  virtual double quality(const GmMatrix& J, double tol) const { 
      assert(tol > 0);
      if (arma::det(J) > tol) {
          GmMatrix U, V;
          GmVector s;
          arma::svd_econ(U, s, V, J, "left");
 
          //Proportion between the smaller / largest eigen value.
          return s[s.n_elem - 1] / s[0];
      }
      return 0;
  }
 
  virtual bool contains(const GmMatrix& X, const GmVector& coord) const { Q_UNUSED(X); Q_UNUSED(coord); return false; }
 
  //------------------------------------------------------------------------------------
  // Helper functions for dimension and centroid calculation by numeric integration
  //------------------------------------------------------------------------------------
  const GmIntegrationRule* cellIntegrationRule() const;
 
  double dimensionByIntegration(const GmMatrix& X, const GmIntegrationRule* ir = NULL) const;
  void   centroidByIntegration (const GmMatrix& X, GmVector& coord, const GmIntegrationRule* ir = NULL) const;
 
private:
  static QAtomicPointer<GmIntegrationRule> _cellIntegrationRules[GM_NUM_CELL_TYPES];
  static QMutex                            _cellIntegrationRulesMutex;  
};
 
 
template <class RuleSet, class RuleSetDefaults>
class GmCellGeometryInfoLineElement : public GmCellGeometryInfo
{
public:
  GmCellGeometryInfoLineElement(GmCellGeometryMetadata&& metadata) : GmCellGeometryInfo(std::move(metadata)) {}
 
  virtual GmIntegrationRule* integrationRule(GmIntegrationRuleType irType, int rule1, int rule2, int rule3, int P, int Q) const
  {
    Q_UNUSED(P); Q_UNUSED(Q);
    return RuleSet::instance<RuleSetDefaults>(this, irType, rule1, rule2, rule3);
  }
 
  // Element edge integration rule factory. See comments on the base class.
  virtual GmBorderIntegrationRule* edgeIntegrationRule(GmIntegrationRuleType irType, int rule1, int P, int Q) const
  {
    Q_UNUSED(irType); Q_UNUSED(rule1); Q_UNUSED(P); Q_UNUSED(Q);
    return NULL;
  }
 
  // Element face integration rule factory. See comments on the base class.
  virtual GmBorderIntegrationRule* faceIntegrationRule(int faceType, GmIntegrationRuleType irType, int rule1, int rule2, int P, int Q) const
  {
    Q_UNUSED(faceType); Q_UNUSED(irType); Q_UNUSED(rule1); Q_UNUSED(rule2); Q_UNUSED(P); Q_UNUSED(Q);
    return NULL;
  }
};
 
 
template <class RuleSet, class RuleSetDefaults, class EdgeRuleSet, class EdgeRuleSetDefaults>
class GmCellGeometryInfoSurfaceElement : public GmCellGeometryInfo
{
public:
  GmCellGeometryInfoSurfaceElement(GmCellGeometryMetadata&& metadata) : GmCellGeometryInfo(std::move(metadata)) {}
 
  // Element integration rule factory. See comments on the base class.
  virtual GmIntegrationRule* integrationRule(GmIntegrationRuleType irType, int rule1, int rule2, int rule3, int P, int Q) const
  {
    Q_UNUSED(P); Q_UNUSED(Q);
    return RuleSet::instance<RuleSetDefaults>(this, irType, rule1, rule2, rule3);
  }
 
  // Element edge integration rule factory. See comments on the base class.
  virtual GmBorderIntegrationRule* edgeIntegrationRule(GmIntegrationRuleType irType, int rule1, int P, int Q) const
  {
    Q_UNUSED(P); Q_UNUSED(Q);
    return EdgeRuleSet::edgeInstance<EdgeRuleSetDefaults>(this, irType, rule1);
  }
 
  // Element face integration rule factory. See comments on the base class.
  virtual GmBorderIntegrationRule* faceIntegrationRule(int faceType, GmIntegrationRuleType irType, int rule1, int rule2, int P, int Q) const
  {
    Q_UNUSED(faceType); Q_UNUSED(irType); Q_UNUSED(rule1); Q_UNUSED(rule2); Q_UNUSED(P); Q_UNUSED(Q);
    return NULL;
  }
};
 
template <class RuleSet, class RuleSetDefaults, class EdgeRuleSet, class EdgeRuleSetDefaults, class FaceRuleSet, class FaceRuleSetDefaults>
class GmCellGeometryInfoSolidElement : public GmCellGeometryInfo
{
public:
  GmCellGeometryInfoSolidElement(GmCellGeometryMetadata&& metadata) : GmCellGeometryInfo(std::move(metadata)) {}
 
  // Element integration rule factory. See comments on the base class.
  virtual GmIntegrationRule* integrationRule(GmIntegrationRuleType irType, int rule1, int rule2, int rule3, int P, int Q) const
  {
    Q_UNUSED(P); Q_UNUSED(Q);
    return RuleSet::instance<RuleSetDefaults>(this, irType, rule1, rule2, rule3);
  }
 
  // Element edge integration rule factory. See comments on the base class.
  virtual GmBorderIntegrationRule* edgeIntegrationRule(GmIntegrationRuleType irType, int rule1, int P, int Q) const
  {
    Q_UNUSED(P); Q_UNUSED(Q);
    return EdgeRuleSet::edgeInstance<EdgeRuleSetDefaults>(this, irType, rule1);
  }
 
  // Element face integration rule factory. See comments on the base class.
  virtual GmBorderIntegrationRule* faceIntegrationRule(int faceType, GmIntegrationRuleType irType, int rule1, int rule2, int P, int Q) const
  {
    Q_UNUSED(P); Q_UNUSED(Q);
    return FaceRuleSet::faceInstance<FaceRuleSetDefaults>(this, faceType, irType, rule1, rule2);
  }
};
 
 
#endif