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

  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 _edgeFace[edge]; }
  
  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); }

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

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


  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* _edgeFace; 

  int* _edgeNodeOffset; 

  int* _CF;   

  int* _CE;

  static const UibhmGemaTemplate* _typeTemplates[GM_NUM_CELL_TYPES];
};


#endif