uibhmTemplate.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 _UIBHM_TEMPLATE_H_
#define _UIBHM_TEMPLATE_H_
 
#include "gmpGemaMeshConfig.h"
 
#include <gmCellGeometry.h>
 
class GMP_GEMAMESH_API_EXPORT UibhmGemaTemplate
{
public:
  ~UibhmGemaTemplate();
 
  // --------------------------------------------------------
  // Basic template properties
  // --------------------------------------------------------
 
  GmCellType type() const { return _g->_type; }
 
  bool isInterface() const { return _g->_interface; }
 
  int numFaces() const { return _g->_nfaces; }
 
  int numEdges() const { return _g->_nedges; }
 
  int numSides() const { return _g->_nfaces == 1 ? numEdges() : numFaces(); }
 
  int numNodes() const { return _g->_nnodes; }
 
  int numVertices() const { return _g->_nvertices; }
 
  int numFaceNodes(int f, bool mid) const 
  { 
    assert(f >= 0 && f < numFaces()); 
    // The following implementation assumes that, for a solid element, if it has a mid volume
    // node it will also have mid face nodes and vice-versa.
    return _g->_faceNodeInfo[f]._faceNodes.size() - (!mid && _midNode != -1);
  }
 
  int numFaceVertices(int f) const { assert(f >= 0 && f < numFaces()); return _vg->_faceNodeInfo[f]._faceNodes.size(); }
 
  int maxNumFaceVertices() const { return _maxNfv; }
 
  const int* faceNodes(int f) const { assert(f >= 0 && f < numFaces()); return _g->_faceNodeInfo[f]._faceNodes.constData(); }
 
  const int* faceVertices(int f) const { assert(f >= 0 && f < numFaces()); return _vg->_faceNodeInfo[f]._faceNodes.constData(); }
 
  int midNode() const { return _midNode; }
 
  const int* adjacentFaces(int f) const { assert(f >= 0 && f < numFaces()); return _CF + f * _maxNfv; }
 
  const int* vertexHalfEdges(int v) const { assert(v >= 0 && v < numVertices()); return _CE + v * numVertices(); }
 
  // --------------------------------------------------------
  // Additional helper functions
  // --------------------------------------------------------
 
  void print(const GmLogCategory& logger, GmLogLevel level) const;
 
  void vertexFaces(int v,    QVarLengthArray<int, 4>& list) const;
  void nodeFaces  (int node, QVarLengthArray<int, 4>& list) const;
 
  int edgeFace(int edge) const { assert(edge >= 0 && edge < numEdges()); return _g->_edgeFaceInfo[edge][0]; } 
  
  bool quadraticMidEdgeNodeAdjacentVertices(int node, int* v1, int* v2) const { return quadraticMidEdgeNodeAdjacentVerticesImpl<false>(node, v1, v2); }
 
  bool quadraticMidEdgeNodeAdjacentVertices(int node, int* v1, int* v2, const int* cellNodes) const { return quadraticMidEdgeNodeAdjacentVerticesImpl<true>(node, v1, v2, cellNodes); }
 
  int midEdgeNode(int f, int e) const 
  { 
    assert(_g->_edgeNodeInfo[_g->_faceEdgeInfo[f][e]]._edgeNodes.size() == 3);
    return _g->_edgeNodeInfo[_g->_faceEdgeInfo[f][e]]._edgeNodes[1];
  }
 
  bool isInterfaceExtraFlowNode(int v) const 
  { 
    assert(v >= 0 && v < _g->_nnodes);  
    return _g->_interface && v >= (_g->_nnodes - _g->_nextraDofNodes); 
  }
 
  int colapsedInterfaceNodeSibling(int v) const;
 
  void vertexAdjacentVertices(int v, QVarLengthArray<int, 4>& list) const { vertexAdjacentImpl<false>(v, _vg, list); }
  
  void vertexAdjacentVertices(int v, QVarLengthArray<int, 4>& list, const int* cellNodes) const { vertexAdjacentImpl<true>(v, _vg, list, cellNodes); }
 
  void vertexAdjacentNodes(int v, QVarLengthArray<int, 4>& list) const { vertexAdjacentImpl<false>(v, _g, list); }
 
  void vertexAdjacentNodes(int v, QVarLengthArray<int, 4>& list, const int* cellNodes) const { vertexAdjacentImpl<true>(v, _g, list, cellNodes); }
 
  void edgeVertices(int e, int* first, int* last) const { edgeVerticesImpl<false>(e, first, last); }
 
  void edgeVertices(int e, int* first, int* last, const int* cellNodes) const { edgeVerticesImpl<true>(e, first, last, cellNodes); }
 
  void edgeNodes(int e, QVarLengthArray<int, 4>& list) const { edgeNodesImpl<false>(e, list); }
 
  void edgeNodes(int e, QVarLengthArray<int, 4>& list, const int* cellNodes) const { edgeNodesImpl<true>(e, list, cellNodes); }
 
  void faceEdgeVertices(int f, int e, int* first, int* last) const { faceEdgeVerticesImpl<false>(f, e, first, last); }
 
  void faceEdgeVertices(int f, int e, int* first, int* last, const int* cellNodes) const { faceEdgeVerticesImpl<true>(f, e, first, last, cellNodes); }
 
  int numFaceEdgeNodes(int f, int e) const { const int* neo = nodeOffsets(f); return neo[e+1] - neo[e] + 1;  }
 
  void faceEdgeNodes(int f, int e, QVarLengthArray<int, 4>& list) const { faceEdgeNodesImpl<false>(f, e, list); }
 
  void faceEdgeNodes(int f, int e, QVarLengthArray<int, 4>& list, const int* cellNodes) const { faceEdgeNodesImpl<true>(f, e, list, cellNodes); }
 
  int numApertureSides() const { assert(_g->_interface); return _g->_interfaceInfo._apertureSides.size(); }
 
  const int* apertureSides() const { assert(_g->_interface); return _g->_interfaceInfo._apertureSides.constData(); }
 
  int firstContactEdge(int f) const { assert(_g->_interface); return _g->_interfaceInfo._contactEdges[f][0]; }
 
  static const UibhmGemaTemplate* typeTemplate(GmCellType t) { assert(t < GM_NUM_CELL_TYPES); return _typeTemplates[t]; }
 
private:
  Q_DISABLE_COPY(UibhmGemaTemplate);
 
  UibhmGemaTemplate(GmCellType t);
 
  friend bool UibhmGemaTemplateInit();
 
  const int* nodeOffsets(int f) const { assert(f >= 0 && f < numFaces()); return _edgeNodeOffset + f * (_maxNfv+1); }
 
  template <bool Translate> bool quadraticMidEdgeNodeAdjacentVerticesImpl(int node, int* v1, int* v2, const int* cellNodes = NULL) const;
  template <bool Translate> void vertexAdjacentImpl  (int v, const GmCellGeometryInfo* g, QVarLengthArray<int, 4>& list, const int* cellNodes = NULL) const;
  template <bool Translate> void edgeVerticesImpl    (int e, int* first, int* last, const int* cellNodes = NULL) const;
  template <bool Translate> void edgeNodesImpl       (int e, QVarLengthArray<int, 4>& list, const int* cellNodes = NULL) const;
  template <bool Translate> void faceEdgeVerticesImpl(int f, int e, int* first, int* last, const int* cellNodes = NULL) const;
  template <bool Translate> void faceEdgeNodesImpl   (int f, int e, QVarLengthArray<int, 4>& list, const int* cellNodes = NULL) const;
 
  const GmCellGeometryInfo* _g;       
  const GmCellGeometryInfo* _vg;      
  int                       _maxNfv;  
  int                       _midNode; 
 
  int* _edgeNodeOffset; 
 
  int* _CF;   
 
  int* _CE;
 
  static const UibhmGemaTemplate* _typeTemplates[GM_NUM_CELL_TYPES];
};
 
 
#endif