uibhmGeometry.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_GEOMETRY_H_
#define _UIBHM_GEOMETRY_H_
 
#include "uibhmTemplate.h"
 
#include "gmpNodeMeshData.h"
#include "gmpCellMeshData.h"
#include "gmpCell.h"
 
class GmPCR;
 
template <bool Hybrid, template <class> class Vector>
class GMP_GEMAMESH_API_EXPORT UibhmGemaCellMeshDataGeometry 
{
public:
 
  template <typename U> using VectorType = Vector<U>;
 
  using NodeData = GmpNodeMeshData<Vector>;
 
  using CellData = GmpCellMeshData<Vector>;
 
  enum { IsHybrid = Hybrid };
 
  UibhmGemaCellMeshDataGeometry(NodeData* nodeData, CellData* cellData, const GmPCR* pcr);
 
  bool updateCellTypes(int numAddedCells);
 
  int numNodes() const { return _nodeData->_numNodes; }
 
  int numCells() const { return _cellData->_numCells; }
 
  GmCell* cell(int cellId) { assert(cellId >= 0 && cellId < _cellData->_numCells);  return _cellData->cell(cellId); }
 
  bool solid() const { return _solid; }
 
  bool hybrid() const { return Hybrid; }
 
  bool hasInterface() const { return _interface; }
 
  bool strange() const { return _strange; }
 
  const UibhmGemaTemplate* const* typeTemplates() const { return _typeTemplateList; }
 
  void faceVertices(int cellId, int face, QVarLengthArray<int, 10>& nodeList) const;
  void faceNodes   (int cellId, int face, bool mid, QVarLengthArray<int, 10>& nodeList) const;
 
  void faceEdgeVertices(int cellId, int face, int edge, int* first, int* last) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->faceEdgeVertices(face, edge, first, last, cn(cellId));
  }
 
  void faceEdgeNodes(int cellId, int face, int edge, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->faceEdgeNodes(face, edge, nodeList, cn(cellId));
  }
 
  int  findNodeIndex(int cellId, int v) const;
  int  colapsedInterfaceNode(int cellId, int v, int localIndex) const;
  int  colapsedInterfaceEdge(int cellId, int face, int faceEdge, int refFace) const;
  int  findFaceEdge (int cellId, int face, int  v1, int  v2) const;
  int  findFaceEdge (int cellId, int face, int* v1, int* v2) const;
  int  findFaceEdgeFromLocalNodes(int cellId, int face, int lv1, int lv2) const;
  int  findFaceEdgeFromMidEdgeNode(int cellId, int face, int v) const;
 
  void edgeVertices(int cellId, int edge, int* first, int* last) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->edgeVertices(edge, first, last, cn(cellId));
  }
  
  void edgeNodes(int cellId, int edge, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->edgeNodes(edge, nodeList, cn(cellId));
  }
 
  int numSides(int cellId) const { const UibhmGemaTemplate* t = tt(cellId); return t ? t->numSides() : 0; }
 
  void sideVertices(int cellId, int side, QVarLengthArray<int, 10>& nodeList) const;
  void sideNodes   (int cellId, int side, QVarLengthArray<int, 10>& nodeList) const;
 
  int midCellNode(int cellId) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    if(t && t->midNode() != -1)
      return cn(cellId)[t->midNode()];
    return -1;
  }
 
  bool quadraticMidEdgeNodeAdjacentVertices(int cellId, int localNode, int* v1, int* v2) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    return t->quadraticMidEdgeNodeAdjacentVertices(localNode, v1, v2, cn(cellId));
  }
 
  void vertexAdjacentVertices(int cellId, int localNode, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->vertexAdjacentVertices(localNode, nodeList, cn(cellId));
  }
 
  void vertexAdjacentNodes(int cellId, int localNode, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->vertexAdjacentNodes(localNode, nodeList, cn(cellId));
  }
 
  static size_t encodeEdge(int v1, int v2)
  {
    if(v1 > v2) qSwap(v1, v2);
    return (((size_t)v1) << 32) | ((size_t)v2);
  }
 
  static void decodeEdge(size_t edge, int* v1, int* v2)
  {
    *v1 = (int)(edge >> 32);
    *v2 = (int)(edge & 0xFFFFFFFF);
  }
 
  const UibhmGemaTemplate* tt(int cellId) const 
  { 
    assert(cellId >= 0 && cellId < numCells());
    if constexpr(Hybrid)
      return _typeTemplateList[_cellData->cell(cellId)->type()];
    else
    {
      Q_UNUSED(cellId);
      return _typeTemplate;
    }
  }
 
  int co(int cellId) const { return ((CellData::CellPrototype*)_cellData->cell(cellId))->offset(); }
 
  const int* cn(int cellId) const { return _cellData->cellNodesPtr(co(cellId)); }
 
  const GmPCR* pcr() const { return _pcr; }
 
  NodeData*    _nodeData;     
  CellData*    _cellData;     
  const GmPCR* _pcr;          
  bool         _solid;        
  bool         _strange;      
  bool         _interface;    
 
  const UibhmGemaTemplate* _typeTemplate; 
 
  const UibhmGemaTemplate* _typeTemplateList[GM_NUM_CELL_TYPES];
};
 
 
#endif